import
struct
re
datetime
import
hglib
from
hglib
import
error
util
templates
merge
context
from
hglib
.
util
import
b
cmdbuilder
BytesIO
strtobytes
class
revision
(
tuple
)
:
    
def
__new__
(
cls
rev
node
tags
branch
author
desc
date
)
:
        
return
tuple
.
__new__
(
cls
(
rev
node
tags
branch
author
desc
date
)
)
    
property
    
def
rev
(
self
)
:
        
return
self
[
0
]
    
property
    
def
node
(
self
)
:
        
return
self
[
1
]
    
property
    
def
tags
(
self
)
:
        
return
self
[
2
]
    
property
    
def
branch
(
self
)
:
        
return
self
[
3
]
    
property
    
def
author
(
self
)
:
        
return
self
[
4
]
    
property
    
def
desc
(
self
)
:
        
return
self
[
5
]
    
property
    
def
date
(
self
)
:
        
return
self
[
6
]
class
hgclient
(
object
)
:
    
inputfmt
=
'
>
I
'
    
outputfmt
=
'
>
cI
'
    
outputfmtsize
=
struct
.
calcsize
(
outputfmt
)
    
retfmt
=
'
>
i
'
    
def
__init__
(
self
path
encoding
configs
connect
=
True
)
:
        
self
.
_args
=
[
hglib
.
HGPATH
'
serve
'
'
-
-
cmdserver
'
'
pipe
'
                
'
-
-
config
'
'
ui
.
interactive
=
True
'
]
        
if
path
:
            
self
.
_args
+
=
[
'
-
R
'
path
]
        
if
configs
:
            
for
config
in
configs
:
                
self
.
_args
+
=
[
'
-
-
config
'
config
]
        
self
.
_env
=
{
'
HGPLAIN
'
:
'
1
'
}
        
if
encoding
:
            
self
.
_env
[
'
HGENCODING
'
]
=
encoding
        
self
.
server
=
None
        
self
.
_version
=
None
        
#
include
the
hidden
changesets
if
True
        
self
.
hidden
=
None
        
self
.
_cbout
=
None
        
self
.
_cberr
=
None
        
self
.
_cbprompt
=
None
        
if
connect
:
            
self
.
open
(
)
        
self
.
_protocoltracefn
=
None
    
def
setcbout
(
self
cbout
)
:
        
"
"
"
        
cbout
is
a
function
that
will
be
called
with
the
stdout
data
of
        
the
command
as
it
runs
.
Call
with
None
to
stop
getting
call
backs
.
        
"
"
"
        
self
.
_cbout
=
cbout
    
def
setcberr
(
self
cberr
)
:
        
"
"
"
        
cberr
is
a
function
that
will
be
called
with
the
stderr
data
of
        
the
command
as
it
runs
.
Call
with
None
to
stop
getting
call
backs
.
        
"
"
"
        
self
.
_cberr
=
cberr
    
def
setcbprompt
(
self
cbprompt
)
:
        
"
"
"
        
cbprompt
is
used
to
reply
to
prompts
by
the
server
        
It
receives
the
max
number
of
bytes
to
return
and
the
        
contents
of
stdout
received
so
far
.
        
Call
with
None
to
stop
getting
call
backs
.
        
cbprompt
is
never
called
from
merge
(
)
or
import_
(
)
        
which
already
handle
the
prompt
.
        
"
"
"
        
self
.
_cbprompt
=
cbprompt
    
def
setprotocoltrace
(
self
tracefn
=
None
)
:
        
"
"
"
        
if
tracefn
is
None
no
trace
calls
will
be
made
.
        
Otherwise
tracefn
is
call
as
tracefn
(
direction
channel
data
)
        
direction
is
'
r
'
for
read
from
server
and
'
w
'
for
write
to
server
        
channel
is
always
None
when
direction
is
'
w
'
        
and
the
channel
-
identified
when
the
direction
is
'
r
'
        
"
"
"
        
self
.
_protocoltracefn
=
tracefn
    
def
__enter__
(
self
)
:
        
if
self
.
server
is
None
:
            
self
.
open
(
)
        
return
self
    
def
__exit__
(
self
exc_type
exc_val
exc_tb
)
:
        
self
.
close
(
)
    
def
_readhello
(
self
)
:
        
"
"
"
read
the
hello
message
the
server
sends
when
started
"
"
"
        
ch
msg
=
self
.
_readchannel
(
)
        
assert
ch
=
=
b
(
'
o
'
)
        
msg
=
msg
.
split
(
b
(
'
\
n
'
)
)
        
self
.
capabilities
=
msg
[
0
]
[
len
(
b
(
'
capabilities
:
'
)
)
:
]
        
if
not
self
.
capabilities
:
            
raise
error
.
ResponseError
(
                
"
bad
hello
message
:
expected
'
capabilities
:
'
"
                
"
got
%
r
"
%
msg
[
0
]
)
        
self
.
capabilities
=
set
(
self
.
capabilities
.
split
(
)
)
        
#
at
the
very
least
the
server
should
be
able
to
run
commands
        
assert
b
(
'
runcommand
'
)
in
self
.
capabilities
        
self
.
_encoding
=
msg
[
1
]
[
len
(
b
(
'
encoding
:
'
)
)
:
]
        
if
not
self
.
_encoding
:
            
raise
error
.
ResponseError
(
"
bad
hello
message
:
expected
'
encoding
:
'
"
                                      
"
got
%
r
"
%
msg
[
1
]
)
    
def
_readchannel
(
self
)
:
        
data
=
self
.
server
.
stdout
.
read
(
hgclient
.
outputfmtsize
)
        
if
not
data
:
            
raise
error
.
ServerError
(
)
        
channel
length
=
struct
.
unpack
(
hgclient
.
outputfmt
data
)
        
if
channel
in
b
(
'
IL
'
)
:
            
return
channel
length
        
else
:
            
return
channel
self
.
server
.
stdout
.
read
(
length
)
    
staticmethod
    
def
_parserevs
(
splitted
)
:
        
'
'
'
splitted
is
a
list
of
fields
according
to
our
rev
.
style
where
        
each
6
fields
compose
one
revision
.
        
'
'
'
        
revs
=
[
]
        
for
rev
in
util
.
grouper
(
7
splitted
)
:
            
#
truncate
the
timezone
and
convert
to
a
local
datetime
            
posixtime
=
float
(
rev
[
6
]
.
split
(
b
(
'
.
'
)
1
)
[
0
]
)
            
dt
=
datetime
.
datetime
.
fromtimestamp
(
posixtime
)
            
revs
.
append
(
revision
(
rev
[
0
]
rev
[
1
]
rev
[
2
]
rev
[
3
]
                                 
rev
[
4
]
rev
[
5
]
dt
)
)
        
return
revs
    
def
runcommand
(
self
args
inchannels
outchannels
)
:
        
def
writeblock
(
data
)
:
            
if
self
.
_protocoltracefn
is
not
None
:
                
self
.
_protocoltracefn
(
'
w
'
None
data
)
            
self
.
server
.
stdin
.
write
(
struct
.
pack
(
self
.
inputfmt
len
(
data
)
)
)
            
self
.
server
.
stdin
.
write
(
data
)
            
self
.
server
.
stdin
.
flush
(
)
        
if
not
self
.
server
:
            
raise
ValueError
(
"
server
not
connected
"
)
        
self
.
server
.
stdin
.
write
(
b
(
'
runcommand
\
n
'
)
)
        
writeblock
(
b
(
'
\
0
'
)
.
join
(
args
)
)
        
while
True
:
            
channel
data
=
self
.
_readchannel
(
)
            
if
self
.
_protocoltracefn
is
not
None
:
                
self
.
_protocoltracefn
(
'
r
'
channel
data
)
            
#
input
channels
            
if
channel
in
inchannels
:
                
writeblock
(
inchannels
[
channel
]
(
data
)
)
            
#
output
channels
            
elif
channel
in
outchannels
:
                
outchannels
[
channel
]
(
data
)
            
#
result
channel
command
finished
            
elif
channel
=
=
b
(
'
r
'
)
:
                
return
struct
.
unpack
(
hgclient
.
retfmt
data
)
[
0
]
            
#
a
channel
that
we
don
'
t
know
and
can
'
t
ignore
            
elif
channel
.
isupper
(
)
:
                
raise
error
.
ResponseError
(
                    
"
unexpected
data
on
required
channel
'
%
s
'
"
%
channel
)
            
#
optional
channel
            
else
:
                
pass
    
def
rawcommand
(
self
args
eh
=
None
prompt
=
None
input
=
None
)
:
        
"
"
"
        
args
is
the
cmdline
(
usually
built
using
util
.
cmdbuilder
)
        
eh
is
an
error
handler
that
is
passed
the
return
code
stdout
and
stderr
        
If
no
eh
is
given
we
raise
a
CommandError
if
ret
!
=
0
        
prompt
is
used
to
reply
to
prompts
by
the
server
        
It
receives
the
max
number
of
bytes
to
return
and
the
contents
of
stdout
        
received
so
far
        
input
is
used
to
reply
to
bulk
data
requests
by
the
server
        
It
receives
the
max
number
of
bytes
to
return
        
"
"
"
        
out
err
=
BytesIO
(
)
BytesIO
(
)
        
outchannels
=
{
}
        
if
self
.
_cbout
is
None
:
            
outchannels
[
b
(
'
o
'
)
]
=
out
.
write
        
else
:
            
def
out_handler
(
data
)
:
                
out
.
write
(
data
)
                
self
.
_cbout
(
data
)
            
outchannels
[
b
(
'
o
'
)
]
=
out_handler
        
if
self
.
_cberr
is
None
:
            
outchannels
[
b
(
'
e
'
)
]
=
err
.
write
        
else
:
            
def
err_handler
(
data
)
:
                
err
.
write
(
data
)
                
self
.
_cberr
(
data
)
            
outchannels
[
b
(
'
e
'
)
]
=
err_handler
        
inchannels
=
{
}
        
if
prompt
is
None
:
            
prompt
=
self
.
_cbprompt
        
if
prompt
is
not
None
:
            
def
func
(
size
)
:
                
reply
=
prompt
(
size
out
.
getvalue
(
)
)
                
return
reply
            
inchannels
[
b
(
'
L
'
)
]
=
func
        
if
input
is
not
None
:
            
inchannels
[
b
(
'
I
'
)
]
=
input
        
ret
=
self
.
runcommand
(
args
inchannels
outchannels
)
        
out
err
=
out
.
getvalue
(
)
err
.
getvalue
(
)
        
if
ret
:
            
if
eh
is
None
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
            
else
:
                
return
eh
(
ret
out
err
)
        
return
out
    
def
open
(
self
)
:
        
if
self
.
server
is
not
None
:
            
raise
ValueError
(
'
server
already
open
'
)
        
self
.
server
=
util
.
popen
(
self
.
_args
self
.
_env
)
        
try
:
            
self
.
_readhello
(
)
        
except
error
.
ServerError
:
            
ret
serr
=
self
.
_close
(
)
            
raise
error
.
ServerError
(
'
server
exited
with
status
%
d
:
%
s
'
                                    
%
(
ret
serr
.
strip
(
)
)
)
        
return
self
    
def
close
(
self
)
:
        
"
"
"
Closes
the
command
server
instance
and
waits
for
it
to
exit
        
returns
the
exit
code
.
        
Attempting
to
call
any
function
afterwards
that
needs
to
        
communicate
with
the
server
will
raise
a
ValueError
.
        
"
"
"
        
return
self
.
_close
(
)
[
0
]
    
def
_close
(
self
)
:
        
_sout
serr
=
self
.
server
.
communicate
(
)
        
ret
=
self
.
server
.
returncode
        
self
.
server
=
None
        
return
ret
serr
    
def
add
(
self
files
=
[
]
dryrun
=
False
subrepos
=
False
include
=
None
            
exclude
=
None
)
:
        
"
"
"
        
Add
the
specified
files
on
the
next
commit
.
        
If
no
files
are
given
add
all
files
to
the
repository
.
        
dryrun
-
do
no
perform
actions
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
Return
whether
all
given
files
were
added
.
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
add
'
)
n
=
dryrun
S
=
subrepos
I
=
include
X
=
exclude
                          
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
addremove
(
self
files
=
[
]
similarity
=
None
dryrun
=
False
include
=
None
                  
exclude
=
None
)
:
        
"
"
"
Add
all
new
files
and
remove
all
missing
files
from
the
repository
.
        
New
files
are
ignored
if
they
match
any
of
the
patterns
in
        
"
.
hgignore
"
.
As
with
add
these
changes
take
effect
at
the
        
next
commit
.
        
similarity
-
used
to
detect
renamed
files
.
With
a
parameter
        
greater
than
0
this
compares
every
removed
file
with
every
        
added
file
and
records
those
similar
enough
as
renames
.
This
        
option
takes
a
percentage
between
0
(
disabled
)
and
100
(
files
        
must
be
identical
)
as
its
parameter
.
Detecting
renamed
files
        
this
way
can
be
expensive
.
After
using
this
option
"
hg
status
        
-
C
"
can
be
used
to
check
which
files
were
identified
as
moved
        
or
renamed
.
        
dryrun
-
do
no
perform
actions
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
Return
True
if
all
files
are
successfully
added
.
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
addremove
'
)
s
=
similarity
n
=
dryrun
I
=
include
                          
X
=
exclude
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
annotate
(
self
files
rev
=
None
nofollow
=
False
text
=
False
user
=
False
                 
file
=
False
date
=
False
number
=
False
changeset
=
False
                 
line
=
False
verbose
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
        
Show
changeset
information
by
line
for
each
file
in
files
.
        
rev
-
annotate
the
specified
revision
        
nofollow
-
don
'
t
follow
copies
and
renames
        
text
-
treat
all
files
as
text
        
user
-
list
the
author
(
long
with
-
v
)
        
file
-
list
the
filename
        
date
-
list
the
date
        
number
-
list
the
revision
number
(
default
)
        
changeset
-
list
the
changeset
        
line
-
show
line
number
at
the
first
appearance
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
Yields
a
(
info
contents
)
tuple
for
each
line
in
a
file
.
Info
is
a
space
        
separated
string
according
to
the
given
options
.
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
annotate
'
)
r
=
rev
no_follow
=
nofollow
a
=
text
                          
u
=
user
f
=
file
d
=
date
n
=
number
c
=
changeset
                          
l
=
line
v
=
verbose
I
=
include
X
=
exclude
                          
hidden
=
self
.
hidden
*
files
)
        
out
=
self
.
rawcommand
(
args
)
        
for
line
in
out
.
splitlines
(
)
:
            
yield
tuple
(
line
.
split
(
b
(
'
:
'
)
1
)
)
    
def
archive
(
self
dest
rev
=
None
nodecode
=
False
prefix
=
None
type
=
None
                
subrepos
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
Create
an
unversioned
archive
of
a
repository
revision
.
        
The
exact
name
of
the
destination
archive
or
directory
is
given
using
a
        
format
string
;
see
export
for
details
.
        
Each
member
added
to
an
archive
file
has
a
directory
prefix
        
prepended
.
Use
prefix
to
specify
a
format
string
for
the
        
prefix
.
The
default
is
the
basename
of
the
archive
with
        
suffixes
removed
.
        
dest
-
destination
path
        
rev
-
revision
to
distribute
.
The
revision
used
is
the
parent
of
the
        
working
directory
if
one
isn
'
t
given
.
        
nodecode
-
do
not
pass
files
through
decoders
        
prefix
-
directory
prefix
for
files
in
archive
        
type
-
type
of
distribution
to
create
.
The
archive
type
is
automatically
        
detected
based
on
file
extension
if
one
isn
'
t
given
.
        
Valid
types
are
:
        
"
files
"
a
directory
full
of
files
(
default
)
        
"
tar
"
tar
archive
uncompressed
        
"
tbz2
"
tar
archive
compressed
using
bzip2
        
"
tgz
"
tar
archive
compressed
using
gzip
        
"
uzip
"
zip
archive
uncompressed
        
"
zip
"
zip
archive
compressed
using
deflate
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
archive
'
)
dest
r
=
rev
                          
no_decode
=
nodecode
p
=
prefix
                          
t
=
type
S
=
subrepos
I
=
include
X
=
exclude
                          
hidden
=
self
.
hidden
)
        
self
.
rawcommand
(
args
)
    
def
backout
(
self
rev
merge
=
False
parent
=
None
tool
=
None
message
=
None
                
logfile
=
None
date
=
None
user
=
None
)
:
        
"
"
"
Prepare
a
new
changeset
with
the
effect
of
rev
undone
in
the
current
        
working
directory
.
        
If
rev
is
the
parent
of
the
working
directory
then
this
new
        
changeset
is
committed
automatically
.
Otherwise
hg
needs
to
        
merge
the
changes
and
the
merged
result
is
left
uncommitted
.
        
rev
-
revision
to
backout
        
merge
-
merge
with
old
dirstate
parent
after
backout
        
parent
-
parent
to
choose
when
backing
out
merge
        
tool
-
specify
merge
tool
        
message
-
use
text
as
commit
message
        
logfile
-
read
commit
message
from
file
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
"
"
"
        
if
message
and
logfile
:
            
raise
ValueError
(
"
cannot
specify
both
a
message
and
a
logfile
"
)
        
args
=
cmdbuilder
(
b
(
'
backout
'
)
r
=
rev
merge
=
merge
parent
=
parent
                          
t
=
tool
m
=
message
l
=
logfile
d
=
date
u
=
user
                          
hidden
=
self
.
hidden
)
        
self
.
rawcommand
(
args
)
    
def
bookmark
(
self
name
rev
=
None
force
=
False
delete
=
False
                 
inactive
=
False
rename
=
None
)
:
        
"
"
"
        
Set
a
bookmark
on
the
working
directory
'
s
parent
revision
or
rev
        
with
the
given
name
.
        
name
-
bookmark
name
        
rev
-
revision
to
bookmark
        
force
-
bookmark
even
if
another
bookmark
with
the
same
name
exists
        
delete
-
delete
the
given
bookmark
        
inactive
-
do
not
mark
the
new
bookmark
active
        
rename
-
rename
the
bookmark
given
by
rename
to
name
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
bookmark
'
)
name
r
=
rev
f
=
force
d
=
delete
                          
i
=
inactive
m
=
rename
)
        
self
.
rawcommand
(
args
)
    
def
bookmarks
(
self
)
:
        
"
"
"
        
Return
the
bookmarks
as
a
list
of
(
name
rev
node
)
and
the
index
of
the
        
current
one
.
        
If
there
isn
'
t
a
current
one
-
1
is
returned
as
the
index
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
bookmarks
'
)
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
bms
=
[
]
        
current
=
-
1
        
if
out
.
rstrip
(
)
!
=
b
(
'
no
bookmarks
set
'
)
:
            
for
line
in
out
.
splitlines
(
)
:
                
iscurrent
line
=
line
[
0
:
3
]
line
[
3
:
]
                
if
b
(
'
*
'
)
in
iscurrent
:
                    
current
=
len
(
bms
)
                
name
line
=
line
.
split
(
b
(
'
'
)
1
)
                
rev
node
=
line
.
split
(
b
(
'
:
'
)
)
                
bms
.
append
(
(
name
int
(
rev
)
node
)
)
        
return
bms
current
    
def
branch
(
self
name
=
None
clean
=
False
force
=
False
)
:
        
"
"
"
When
name
isn
'
t
given
return
the
current
branch
name
.
Otherwise
        
set
the
working
directory
branch
name
(
the
branch
will
not
        
exist
in
the
repository
until
the
next
commit
)
.
Standard
        
practice
recommends
that
primary
development
take
place
on
the
        
'
default
'
branch
.
        
When
clean
is
True
reset
and
return
the
working
directory
        
branch
to
that
of
the
parent
of
the
working
directory
        
negating
a
previous
branch
change
.
        
name
-
new
branch
name
        
clean
-
reset
branch
name
to
parent
branch
name
        
force
-
set
branch
name
even
if
it
shadows
an
existing
branch
        
"
"
"
        
if
name
and
clean
:
            
raise
ValueError
(
'
cannot
use
both
name
and
clean
'
)
        
args
=
cmdbuilder
(
b
(
'
branch
'
)
name
f
=
force
C
=
clean
)
        
out
=
self
.
rawcommand
(
args
)
.
rstrip
(
)
        
if
name
:
            
return
name
        
elif
not
clean
:
            
return
out
        
else
:
            
#
len
(
'
reset
working
directory
to
branch
'
)
=
=
34
            
return
out
[
34
:
]
    
def
branches
(
self
active
=
False
closed
=
False
)
:
        
"
"
"
        
Returns
the
repository
'
s
named
branches
as
a
list
of
(
name
rev
node
)
.
        
active
-
show
only
branches
that
have
unmerged
heads
        
closed
-
show
normal
and
closed
branches
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
branches
'
)
a
=
active
c
=
closed
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
branches
=
[
]
        
for
line
in
out
.
rstrip
(
)
.
splitlines
(
)
:
            
namerev
node
=
line
.
rsplit
(
b
(
'
:
'
)
1
)
            
name
rev
=
namerev
.
rsplit
(
b
(
'
'
)
1
)
            
name
=
name
.
rstrip
(
)
            
node
=
node
.
split
(
)
[
0
]
#
get
rid
of
'
(
inactive
)
'
            
branches
.
append
(
(
name
int
(
rev
)
node
)
)
        
return
branches
    
def
bundle
(
self
file
destrepo
=
None
rev
=
[
]
branch
=
[
]
base
=
[
]
all
=
False
               
force
=
False
type
=
None
ssh
=
None
remotecmd
=
None
               
insecure
=
False
)
:
        
"
"
"
Generate
a
compressed
changegroup
file
collecting
changesets
not
        
known
to
be
in
another
repository
.
        
If
destrepo
isn
'
t
given
then
hg
assumes
the
destination
will
have
all
        
the
nodes
you
specify
with
base
.
To
create
a
bundle
containing
all
        
changesets
use
all
(
or
set
base
to
'
null
'
)
.
        
file
-
destination
file
name
        
destrepo
-
repository
to
look
for
changes
        
rev
-
a
changeset
intended
to
be
added
to
the
destination
        
branch
-
a
specific
branch
you
would
like
to
bundle
        
base
-
a
base
changeset
assumed
to
be
available
at
the
destination
        
all
-
bundle
all
changesets
in
the
repository
        
type
-
bundle
compression
type
to
use
available
compression
         
methods
are
:
none
bzip2
and
gzip
(
default
:
bzip2
)
        
force
-
run
even
when
the
destrepo
is
unrelated
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
         
web
.
cacerts
config
)
        
Return
True
if
a
bundle
was
created
False
if
no
changes
were
found
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
bundle
'
)
file
destrepo
f
=
force
r
=
rev
b
=
branch
                          
base
=
base
a
=
all
t
=
type
e
=
ssh
remotecmd
=
remotecmd
                          
insecure
=
insecure
hidden
=
self
.
hidden
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
cat
(
self
files
rev
=
None
output
=
None
)
:
        
"
"
"
Return
a
string
containing
the
specified
files
as
they
were
at
the
        
given
revision
.
If
no
revision
is
given
the
parent
of
the
working
        
directory
is
used
or
tip
if
no
revision
is
checked
out
.
        
If
output
is
given
writes
the
contents
to
the
specified
file
.
        
The
name
of
the
file
is
given
using
a
format
string
.
The
        
formatting
rules
are
the
same
as
for
the
export
command
with
        
the
following
additions
:
        
"
%
s
"
basename
of
file
being
printed
        
"
%
d
"
dirname
of
file
being
printed
or
'
.
'
if
in
repository
root
        
"
%
p
"
root
-
relative
path
name
of
file
being
printed
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
cat
'
)
r
=
rev
o
=
output
hidden
=
self
.
hidden
*
files
)
        
out
=
self
.
rawcommand
(
args
)
        
if
not
output
:
            
return
out
    
def
clone
(
self
source
=
b
(
'
.
'
)
dest
=
None
branch
=
None
updaterev
=
None
              
revrange
=
None
)
:
        
"
"
"
        
Create
a
copy
of
an
existing
repository
specified
by
source
in
a
new
        
directory
dest
.
        
If
dest
isn
'
t
specified
it
defaults
to
the
basename
of
source
.
        
branch
-
clone
only
the
specified
branch
        
updaterev
-
revision
tag
or
branch
to
check
out
        
revrange
-
include
the
specified
changeset
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
clone
'
)
source
dest
b
=
branch
                          
u
=
updaterev
r
=
revrange
)
        
self
.
rawcommand
(
args
)
    
def
init
(
self
dest
ssh
=
None
remotecmd
=
None
insecure
=
False
)
:
        
args
=
util
.
cmdbuilder
(
'
init
'
dest
e
=
ssh
remotecmd
=
remotecmd
                               
insecure
=
insecure
)
        
self
.
rawcommand
(
args
)
    
def
commit
(
self
message
=
None
logfile
=
None
addremove
=
False
               
closebranch
=
False
date
=
None
user
=
None
include
=
None
               
exclude
=
None
amend
=
False
)
:
        
"
"
"
        
Commit
changes
reported
by
status
into
the
repository
.
        
message
-
the
commit
message
        
logfile
-
read
commit
message
from
file
        
addremove
-
mark
new
/
missing
files
as
added
/
removed
before
committing
        
closebranch
-
mark
a
branch
as
closed
hiding
it
from
the
branch
list
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
amend
-
amend
the
parent
of
the
working
dir
        
"
"
"
        
if
amend
and
message
is
None
and
logfile
is
None
:
            
#
retrieve
current
commit
message
            
message
=
self
.
log
(
b
(
'
.
'
)
)
[
0
]
[
5
]
        
if
message
is
None
and
logfile
is
None
and
not
amend
:
            
raise
ValueError
(
"
must
provide
at
least
a
message
or
a
logfile
"
)
        
elif
message
and
logfile
:
            
raise
ValueError
(
"
cannot
specify
both
a
message
and
a
logfile
"
)
        
#
-
-
debug
will
print
the
committed
cset
        
args
=
cmdbuilder
(
b
(
'
commit
'
)
debug
=
True
m
=
message
A
=
addremove
                          
close_branch
=
closebranch
d
=
date
u
=
user
l
=
logfile
                          
I
=
include
X
=
exclude
amend
=
amend
)
        
out
=
self
.
rawcommand
(
args
)
        
m
=
re
.
search
(
b
(
r
'
^
committed
changeset
(
\
d
+
)
:
(
[
0
-
9a
-
f
]
+
)
'
)
out
                      
re
.
MULTILINE
)
        
if
not
m
:
            
raise
ValueError
(
'
revision
and
node
not
found
in
hg
output
:
%
r
'
                             
%
out
)
        
rev
node
=
m
.
groups
(
)
        
return
int
(
rev
)
node
    
def
config
(
self
names
=
[
]
untrusted
=
False
showsource
=
False
)
:
        
"
"
"
Return
a
list
of
(
section
key
value
)
config
settings
from
all
        
hgrc
files
        
When
showsource
is
specified
return
(
source
section
key
value
)
where
        
source
is
of
the
form
filename
:
[
line
]
        
"
"
"
        
def
splitline
(
s
)
:
            
k
value
=
s
.
rstrip
(
)
.
split
(
b
(
'
=
'
)
1
)
            
section
key
=
k
.
split
(
b
(
'
.
'
)
1
)
            
return
section
key
value
        
if
not
isinstance
(
names
list
)
:
            
names
=
[
names
]
        
args
=
cmdbuilder
(
b
(
'
showconfig
'
)
u
=
untrusted
debug
=
showsource
                          
*
names
)
        
out
=
self
.
rawcommand
(
args
)
        
conf
=
[
]
        
if
showsource
:
            
out
=
util
.
skiplines
(
out
b
(
'
read
config
from
:
'
)
)
            
for
line
in
out
.
splitlines
(
)
:
                
m
=
re
.
match
(
b
(
r
"
(
.
+
?
:
(
?
:
\
d
+
:
)
?
)
(
.
*
)
"
)
line
)
                
t
=
splitline
(
m
.
group
(
2
)
)
                
conf
.
append
(
(
m
.
group
(
1
)
[
:
-
1
]
t
[
0
]
t
[
1
]
t
[
2
]
)
)
        
else
:
            
for
line
in
out
.
splitlines
(
)
:
                
conf
.
append
(
splitline
(
line
)
)
        
return
conf
    
property
    
def
encoding
(
self
)
:
        
"
"
"
        
Return
the
server
'
s
encoding
(
as
reported
in
the
hello
message
)
.
        
"
"
"
        
if
not
b
(
'
getencoding
'
)
in
self
.
capabilities
:
            
raise
CapabilityError
(
'
getencoding
'
)
        
if
not
self
.
_encoding
:
            
self
.
server
.
stdin
.
write
(
b
(
'
getencoding
\
n
'
)
)
            
self
.
_encoding
=
self
.
_readfromchannel
(
'
r
'
)
        
return
self
.
_encoding
    
def
copy
(
self
source
dest
after
=
False
force
=
False
dryrun
=
False
             
include
=
None
exclude
=
None
)
:
        
"
"
"
Mark
dest
as
having
copies
of
source
files
.
If
dest
is
a
        
directory
copies
are
put
in
that
directory
.
If
dest
is
a
        
file
then
source
must
be
a
string
.
        
Returns
True
on
success
False
if
errors
are
encountered
.
        
source
-
a
file
or
a
list
of
files
        
dest
-
a
destination
file
or
directory
        
after
-
record
a
copy
that
has
already
occurred
        
force
-
forcibly
copy
over
an
existing
managed
file
        
dryrun
-
do
not
perform
actions
just
print
output
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
source
list
)
:
            
source
=
[
source
]
        
source
.
append
(
dest
)
        
args
=
cmdbuilder
(
b
(
'
copy
'
)
A
=
after
f
=
force
n
=
dryrun
                          
I
=
include
X
=
exclude
*
source
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
diff
(
self
files
=
[
]
revs
=
[
]
change
=
None
text
=
False
             
git
=
False
nodates
=
False
showfunction
=
False
             
reverse
=
False
ignoreallspace
=
False
             
ignorespacechange
=
False
ignoreblanklines
=
False
             
unified
=
None
stat
=
False
subrepos
=
False
include
=
None
             
exclude
=
None
)
:
        
"
"
"
        
Return
differences
between
revisions
for
the
specified
files
.
        
revs
-
a
revision
or
a
list
of
two
revisions
to
diff
        
change
-
change
made
by
revision
        
text
-
treat
all
files
as
text
        
git
-
use
git
extended
diff
format
        
nodates
-
omit
dates
from
diff
headers
        
showfunction
-
show
which
function
each
change
is
in
        
reverse
-
produce
a
diff
that
undoes
the
changes
        
ignoreallspace
-
ignore
white
space
when
comparing
lines
        
ignorespacechange
-
ignore
changes
in
the
amount
of
white
space
        
ignoreblanklines
-
ignore
changes
whose
lines
are
all
blank
        
unified
-
number
of
lines
of
context
to
show
        
stat
-
output
diffstat
-
style
summary
of
changes
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
change
and
revs
:
            
raise
ValueError
(
'
cannot
specify
both
change
and
rev
'
)
        
args
=
cmdbuilder
(
b
(
'
diff
'
)
r
=
list
(
map
(
strtobytes
revs
)
)
c
=
change
                          
a
=
text
g
=
git
nodates
=
nodates
                          
p
=
showfunction
reverse
=
reverse
                          
w
=
ignoreallspace
b
=
ignorespacechange
                          
B
=
ignoreblanklines
U
=
unified
stat
=
stat
                          
S
=
subrepos
I
=
include
X
=
exclude
hidden
=
self
.
hidden
                          
*
files
)
        
return
self
.
rawcommand
(
args
)
    
def
export
(
self
revs
output
=
None
switchparent
=
False
               
text
=
False
git
=
False
nodates
=
False
)
:
        
"
"
"
Return
the
header
and
diffs
for
one
or
more
changesets
.
When
        
output
is
given
dumps
to
file
.
The
name
of
the
file
is
given
        
using
a
format
string
.
The
formatting
rules
are
as
follows
:
        
"
%
%
"
literal
"
%
"
character
        
"
%
H
"
changeset
hash
(
40
hexadecimal
digits
)
        
"
%
N
"
number
of
patches
being
generated
        
"
%
R
"
changeset
revision
number
        
"
%
b
"
basename
of
the
exporting
repository
        
"
%
h
"
short
-
form
changeset
hash
(
12
hexadecimal
digits
)
        
"
%
n
"
zero
-
padded
sequence
number
starting
at
1
        
"
%
r
"
zero
-
padded
changeset
revision
number
        
output
-
print
output
to
file
with
formatted
name
        
switchparent
-
diff
against
the
second
parent
        
rev
-
a
revision
or
list
of
revisions
to
export
        
text
-
treat
all
files
as
text
        
git
-
use
git
extended
diff
format
        
nodates
-
omit
dates
from
diff
headers
        
"
"
"
        
if
not
isinstance
(
revs
list
)
:
            
revs
=
[
revs
]
        
args
=
cmdbuilder
(
b
(
'
export
'
)
o
=
output
switch_parent
=
switchparent
                          
a
=
text
g
=
git
nodates
=
nodates
hidden
=
self
.
hidden
                          
*
revs
)
        
out
=
self
.
rawcommand
(
args
)
        
if
output
is
None
:
            
return
out
    
def
forget
(
self
files
include
=
None
exclude
=
None
)
:
        
"
"
"
Mark
the
specified
files
so
they
will
no
longer
be
tracked
after
        
the
next
commit
.
        
This
only
removes
files
from
the
current
branch
not
from
the
entire
        
project
history
and
it
does
not
delete
them
from
the
working
directory
.
        
Returns
True
on
success
.
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
forget
'
)
I
=
include
X
=
exclude
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
grep
(
self
pattern
files
=
[
]
all
=
False
text
=
False
follow
=
False
             
ignorecase
=
False
fileswithmatches
=
False
line
=
False
user
=
False
             
date
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
Search
for
a
pattern
in
specified
files
and
revisions
.
        
This
behaves
differently
than
Unix
grep
.
It
only
accepts
Python
/
Perl
        
regexps
.
It
searches
repository
history
not
the
working
directory
.
        
It
always
prints
the
revision
number
in
which
a
match
appears
.
        
Yields
(
filename
revision
[
line
[
match
status
[
user
        
[
date
[
match
]
]
]
]
]
)
per
match
depending
on
the
given
options
.
        
all
-
print
all
revisions
that
match
        
text
-
treat
all
files
as
text
        
follow
-
follow
changeset
history
or
file
history
across
         
copies
and
renames
        
ignorecase
-
ignore
case
when
matching
        
fileswithmatches
-
return
only
filenames
and
revisions
that
match
        
line
-
return
line
numbers
in
the
result
tuple
        
user
-
return
the
author
in
the
result
tuple
        
date
-
return
the
date
in
the
result
tuple
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
grep
'
)
all
=
all
a
=
text
f
=
follow
i
=
ignorecase
                          
l
=
fileswithmatches
n
=
line
u
=
user
d
=
date
                          
I
=
include
X
=
exclude
hidden
=
self
.
hidden
                          
*
[
pattern
]
+
files
)
        
args
.
append
(
b
(
'
-
0
'
)
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
            
return
b
(
'
'
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
.
split
(
b
(
'
\
0
'
)
)
        
fieldcount
=
3
        
if
user
:
            
fieldcount
+
=
1
        
if
date
:
            
fieldcount
+
=
1
        
if
line
:
            
fieldcount
+
=
1
        
if
all
:
            
fieldcount
+
=
1
        
if
fileswithmatches
:
            
fieldcount
-
=
1
        
return
util
.
grouper
(
fieldcount
out
)
    
def
heads
(
self
rev
=
[
]
startrev
=
[
]
topological
=
False
closed
=
False
)
:
        
"
"
"
Return
a
list
of
current
repository
heads
or
branch
heads
.
        
rev
-
return
only
branch
heads
on
the
branches
associated
with
        
the
specified
changesets
.
        
startrev
-
return
only
heads
which
are
descendants
of
the
given
revs
.
        
topological
-
named
branch
mechanics
will
be
ignored
and
only
changesets
        
without
children
will
be
shown
.
        
closed
-
normal
and
closed
branch
heads
.
        
"
"
"
        
if
not
isinstance
(
rev
list
)
:
            
rev
=
[
rev
]
        
args
=
cmdbuilder
(
b
(
'
heads
'
)
r
=
startrev
t
=
topological
c
=
closed
                          
template
=
templates
.
changeset
hidden
=
self
.
hidden
                          
*
rev
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
            
return
b
(
'
'
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
        
return
self
.
_parserevs
(
out
)
    
def
identify
(
self
rev
=
None
source
=
None
num
=
False
id
=
False
branch
=
False
                 
tags
=
False
bookmarks
=
False
)
:
        
"
"
"
Return
a
summary
string
identifying
the
repository
state
at
rev
        
using
one
or
two
parent
hash
identifiers
followed
by
a
"
+
"
if
        
the
working
directory
has
uncommitted
changes
the
branch
name
        
(
if
not
default
)
a
list
of
tags
and
a
list
of
bookmarks
.
        
When
rev
is
not
given
return
a
summary
string
of
the
current
        
state
of
the
repository
.
        
Specifying
source
as
a
repository
root
or
Mercurial
bundle
will
cause
        
lookup
to
operate
on
that
repository
/
bundle
.
        
num
-
show
local
revision
number
        
id
-
show
global
revision
id
        
branch
-
show
branch
        
tags
-
show
tags
        
bookmarks
-
show
bookmarks
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
identify
'
)
source
r
=
rev
n
=
num
i
=
id
                          
b
=
branch
t
=
tags
B
=
bookmarks
                          
hidden
=
self
.
hidden
)
        
return
self
.
rawcommand
(
args
)
    
def
import_
(
self
patches
strip
=
None
force
=
False
nocommit
=
False
                
bypass
=
False
exact
=
False
importbranch
=
False
message
=
None
                
date
=
None
user
=
None
similarity
=
None
)
:
        
"
"
"
Import
the
specified
patches
which
can
be
a
list
of
file
names
or
a
        
file
-
like
object
and
commit
them
individually
(
unless
nocommit
is
        
specified
)
.
        
strip
-
directory
strip
option
for
patch
.
This
has
the
same
        
meaning
as
the
corresponding
patch
option
(
default
:
1
)
        
force
-
skip
check
for
outstanding
uncommitted
changes
        
nocommit
-
don
'
t
commit
just
update
the
working
directory
        
bypass
-
apply
patch
without
touching
the
working
directory
        
exact
-
apply
patch
to
the
nodes
from
which
it
was
generated
        
importbranch
-
use
any
branch
information
in
patch
(
implied
by
exact
)
        
message
-
the
commit
message
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
similarity
-
guess
renamed
files
by
similarity
(
0
<
=
s
<
=
100
)
        
"
"
"
        
if
hasattr
(
patches
'
read
'
)
and
hasattr
(
patches
'
readline
'
)
:
            
patch
=
patches
            
def
readline
(
size
output
)
:
                
return
patch
.
readline
(
size
)
            
stdin
=
True
            
patches
=
(
)
            
prompt
=
readline
            
input
=
patch
.
read
        
else
:
            
stdin
=
False
            
prompt
=
None
            
input
=
None
        
args
=
cmdbuilder
(
b
(
'
import
'
)
strip
=
strip
force
=
force
                          
no_commit
=
nocommit
bypass
=
bypass
exact
=
exact
                          
import_branch
=
importbranch
message
=
message
                          
date
=
date
user
=
user
similarity
=
similarity
_
=
stdin
                          
*
patches
)
        
self
.
rawcommand
(
args
prompt
=
prompt
input
=
input
)
    
def
incoming
(
self
revrange
=
None
path
=
None
force
=
False
newest
=
False
                 
bundle
=
None
bookmarks
=
False
branch
=
None
limit
=
None
                 
nomerges
=
False
subrepos
=
False
)
:
        
"
"
"
Return
new
changesets
found
in
the
specified
path
or
the
default
pull
        
location
.
        
When
bookmarks
=
True
return
a
list
of
(
name
node
)
of
incoming
        
bookmarks
.
        
revrange
-
a
remote
changeset
or
list
of
changesets
intended
to
be
added
        
force
-
run
even
if
remote
repository
is
unrelated
        
newest
-
show
newest
record
first
        
bundle
-
avoid
downloading
the
changesets
twice
and
store
the
         
bundles
into
the
specified
file
.
        
bookmarks
-
compare
bookmarks
(
this
changes
the
return
value
)
        
branch
-
a
specific
branch
you
would
like
to
pull
        
limit
-
limit
number
of
changes
returned
        
nomerges
-
do
not
show
merges
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
web
.
cacerts
config
)
        
subrepos
-
recurse
into
subrepositories
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
incoming
'
)
path
                          
template
=
templates
.
changeset
r
=
revrange
                          
f
=
force
n
=
newest
bundle
=
bundle
                          
B
=
bookmarks
b
=
branch
l
=
limit
M
=
nomerges
                          
S
=
subrepos
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
        
if
not
out
:
            
return
[
]
        
out
=
util
.
eatlines
(
out
2
)
        
if
bookmarks
:
            
bms
=
[
]
            
for
line
in
out
.
splitlines
(
)
:
                
bms
.
append
(
tuple
(
line
.
split
(
)
)
)
            
return
bms
        
else
:
            
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
            
return
self
.
_parserevs
(
out
)
    
def
log
(
self
revrange
=
None
files
=
[
]
follow
=
False
            
followfirst
=
False
date
=
None
copies
=
False
keyword
=
None
            
removed
=
False
onlymerges
=
False
user
=
None
branch
=
None
            
prune
=
None
hidden
=
None
limit
=
None
nomerges
=
False
            
include
=
None
exclude
=
None
)
:
        
"
"
"
Return
the
revision
history
of
the
specified
files
or
the
entire
        
project
.
        
File
history
is
shown
without
following
rename
or
copy
history
of
files
.
        
Use
follow
with
a
filename
to
follow
history
across
renames
and
copies
.
        
follow
without
a
filename
will
only
show
ancestors
or
descendants
of
the
        
starting
revision
.
followfirst
only
follows
the
first
parent
of
merge
        
revisions
.
        
If
revrange
isn
'
t
specified
the
default
is
"
tip
:
0
"
unless
        
follow
is
set
in
which
case
the
working
directory
parent
is
        
used
as
the
starting
revision
.
        
The
returned
changeset
is
a
named
tuple
with
the
following
        
string
fields
:
            
-
rev
            
-
node
            
-
tags
(
space
delimited
)
            
-
branch
            
-
author
            
-
desc
        
follow
-
follow
changeset
history
or
file
history
across
         
copies
and
renames
        
followfirst
-
only
follow
the
first
parent
of
merge
changesets
        
date
-
show
revisions
matching
date
spec
        
copies
-
show
copied
files
        
keyword
-
do
case
-
insensitive
search
for
a
given
text
        
removed
-
include
revisions
where
files
were
removed
        
onlymerges
-
show
only
merges
        
user
-
revisions
committed
by
user
        
branch
-
show
changesets
within
the
given
named
branch
        
prune
-
do
not
display
revision
or
any
of
its
ancestors
        
hidden
-
show
hidden
changesets
        
limit
-
limit
number
of
changes
displayed
        
nomerges
-
do
not
show
merges
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
hidden
is
None
:
            
hidden
=
self
.
hidden
        
args
=
cmdbuilder
(
b
(
'
log
'
)
template
=
templates
.
changeset
                          
r
=
revrange
f
=
follow
follow_first
=
followfirst
                          
d
=
date
C
=
copies
k
=
keyword
removed
=
removed
                          
m
=
onlymerges
u
=
user
b
=
branch
P
=
prune
                          
l
=
limit
M
=
nomerges
I
=
include
X
=
exclude
                          
hidden
=
hidden
*
files
)
        
out
=
self
.
rawcommand
(
args
)
        
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
        
return
self
.
_parserevs
(
out
)
    
def
manifest
(
self
rev
=
None
all
=
False
)
:
        
"
"
"
Yields
(
nodeid
permission
executable
symlink
file
path
)
tuples
        
for
version
controlled
files
for
the
given
revision
.
If
no
        
revision
is
given
the
first
parent
of
the
working
directory
        
is
used
or
the
null
revision
if
no
revision
is
checked
out
.
        
When
all
is
True
all
files
from
all
revisions
are
yielded
        
(
just
the
name
)
.
This
includes
deleted
and
renamed
files
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
manifest
'
)
r
=
rev
all
=
all
debug
=
True
                          
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
if
all
:
            
for
line
in
out
.
splitlines
(
)
:
                
yield
line
        
else
:
            
for
line
in
out
.
splitlines
(
)
:
                
node
=
line
[
0
:
40
]
                
perm
=
line
[
41
:
44
]
                
symlink
=
line
[
45
:
46
]
=
=
b
(
'
'
)
                
executable
=
line
[
45
:
46
]
=
=
b
(
'
*
'
)
                
yield
node
perm
executable
symlink
line
[
47
:
]
    
def
merge
(
self
rev
=
None
force
=
False
tool
=
None
cb
=
merge
.
handlers
.
abort
)
:
        
"
"
"
Merge
working
directory
with
rev
.
If
no
revision
is
specified
the
        
working
directory
'
s
parent
is
a
head
revision
and
the
current
        
branch
contains
exactly
one
other
head
the
other
head
is
        
merged
with
by
default
.
        
The
current
working
directory
is
updated
with
all
changes
made
in
the
        
requested
revision
since
the
last
common
predecessor
revision
.
        
Files
that
changed
between
either
parent
are
marked
as
changed
for
the
        
next
commit
and
a
commit
must
be
performed
before
any
further
updates
to
        
the
repository
are
allowed
.
The
next
commit
will
have
two
parents
.
        
force
-
force
a
merge
with
outstanding
changes
        
tool
-
can
be
used
to
specify
the
merge
tool
used
for
file
merges
.
It
        
overrides
the
HGMERGE
environment
variable
and
your
configuration
files
.
        
cb
-
controls
the
behaviour
when
Mercurial
prompts
what
to
do
        
with
regard
to
a
specific
file
e
.
g
.
when
one
parent
modified
        
a
file
and
the
other
removed
it
.
It
can
be
one
of
        
merge
.
handlers
or
a
function
that
gets
a
single
argument
        
which
are
the
contents
of
stdout
.
It
should
return
one
of
the
        
expected
choices
(
a
single
character
)
.
        
"
"
"
        
#
we
can
'
t
really
use
-
-
preview
since
merge
doesn
'
t
support
-
-
template
        
args
=
cmdbuilder
(
b
(
'
merge
'
)
r
=
rev
f
=
force
t
=
tool
)
        
prompt
=
None
        
if
cb
is
merge
.
handlers
.
abort
:
            
prompt
=
cb
        
elif
cb
is
merge
.
handlers
.
noninteractive
:
            
args
.
append
(
b
(
'
-
y
'
)
)
        
else
:
            
prompt
=
lambda
size
output
:
cb
(
output
)
+
b
(
'
\
n
'
)
        
self
.
rawcommand
(
args
prompt
=
prompt
)
    
def
move
(
self
source
dest
after
=
False
force
=
False
dryrun
=
False
             
include
=
None
exclude
=
None
)
:
        
"
"
"
Mark
dest
as
copies
of
source
;
mark
source
for
deletion
.
If
dest
        
is
a
directory
copies
are
put
in
that
directory
.
If
dest
is
a
        
file
then
source
must
be
a
string
.
        
Returns
True
on
success
False
if
errors
are
encountered
.
        
source
-
a
file
or
a
list
of
files
        
dest
-
a
destination
file
or
directory
        
after
-
record
a
rename
that
has
already
occurred
        
force
-
forcibly
copy
over
an
existing
managed
file
        
dryrun
-
do
not
perform
actions
just
print
output
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
source
list
)
:
            
source
=
[
source
]
        
source
.
append
(
dest
)
        
args
=
cmdbuilder
(
b
(
'
move
'
)
A
=
after
f
=
force
n
=
dryrun
                          
I
=
include
X
=
exclude
*
source
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
outgoing
(
self
revrange
=
None
path
=
None
force
=
False
newest
=
False
                 
bookmarks
=
False
branch
=
None
limit
=
None
nomerges
=
False
                 
subrepos
=
False
)
:
        
"
"
"
Return
changesets
not
found
in
the
specified
path
or
the
default
push
        
location
.
        
When
bookmarks
=
True
return
a
list
of
(
name
node
)
of
        
bookmarks
that
will
be
pushed
.
        
revrange
-
a
(
list
of
)
changeset
intended
to
be
included
in
        
the
destination
force
-
run
even
when
the
destination
is
        
unrelated
newest
-
show
newest
record
first
branch
-
a
        
specific
branch
you
would
like
to
push
limit
-
limit
number
of
        
changes
displayed
nomerges
-
do
not
show
merges
ssh
-
specify
        
ssh
command
to
use
remotecmd
-
specify
hg
command
to
run
on
        
the
remote
side
insecure
-
do
not
verify
server
certificate
        
(
ignoring
web
.
cacerts
config
)
subrepos
-
recurse
into
        
subrepositories
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
outgoing
'
)
                          
path
                          
template
=
templates
.
changeset
r
=
revrange
                          
f
=
force
n
=
newest
B
=
bookmarks
                          
b
=
branch
S
=
subrepos
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
        
if
not
out
:
            
return
[
]
        
out
=
util
.
eatlines
(
out
2
)
        
if
bookmarks
:
            
bms
=
[
]
            
for
line
in
out
.
splitlines
(
)
:
                
bms
.
append
(
tuple
(
line
.
split
(
)
)
)
            
return
bms
        
else
:
            
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
            
return
self
.
_parserevs
(
out
)
    
def
parents
(
self
rev
=
None
file
=
None
)
:
        
"
"
"
Return
the
working
directory
'
s
parent
revisions
.
If
rev
is
given
        
the
parent
of
that
revision
will
be
printed
.
If
file
is
given
        
the
revision
in
which
the
file
was
last
changed
(
before
the
        
working
directory
revision
or
the
revision
specified
by
rev
)
        
is
returned
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
parents
'
)
file
template
=
templates
.
changeset
                          
r
=
rev
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
if
not
out
:
            
return
        
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
        
return
self
.
_parserevs
(
out
)
    
def
paths
(
self
name
=
None
)
:
        
"
"
"
        
Return
the
definition
of
given
symbolic
path
name
.
If
no
name
is
given
        
return
a
dictionary
of
pathname
:
url
of
all
available
names
.
        
Path
names
are
defined
in
the
[
paths
]
section
of
your
configuration
file
        
and
in
"
/
etc
/
mercurial
/
hgrc
"
.
If
run
inside
a
repository
"
.
hg
/
hgrc
"
is
        
used
too
.
        
"
"
"
        
if
not
name
:
            
out
=
self
.
rawcommand
(
[
b
(
'
paths
'
)
]
)
            
if
not
out
:
                
return
{
}
            
return
dict
(
[
s
.
split
(
b
(
'
=
'
)
)
                         
for
s
in
out
.
rstrip
(
)
.
split
(
b
(
'
\
n
'
)
)
]
)
        
else
:
            
args
=
cmdbuilder
(
b
(
'
paths
'
)
name
)
            
out
=
self
.
rawcommand
(
args
)
            
return
out
.
rstrip
(
)
    
def
pull
(
self
source
=
None
rev
=
None
update
=
False
force
=
False
             
bookmark
=
None
branch
=
None
ssh
=
None
remotecmd
=
None
             
insecure
=
False
tool
=
None
)
:
        
"
"
"
Pull
changes
from
a
remote
repository
.
        
This
finds
all
changes
from
the
repository
specified
by
source
        
and
adds
them
to
this
repository
.
If
source
is
omitted
the
        
'
default
'
path
will
be
used
.
By
default
this
does
not
update
        
the
copy
of
the
project
in
the
working
directory
.
        
Returns
True
on
success
False
if
update
was
given
and
there
were
        
unresolved
files
.
        
update
-
update
to
new
branch
head
if
changesets
were
pulled
        
force
-
run
even
when
remote
repository
is
unrelated
        
rev
-
a
(
list
of
)
remote
changeset
intended
to
be
added
        
bookmark
-
(
list
of
)
bookmark
to
pull
        
branch
-
a
(
list
of
)
specific
branch
you
would
like
to
pull
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
         
web
.
cacerts
config
)
        
tool
-
specify
merge
tool
for
rebase
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
pull
'
)
source
r
=
rev
u
=
update
f
=
force
                          
B
=
bookmark
b
=
branch
e
=
ssh
                          
remotecmd
=
remotecmd
insecure
=
insecure
                          
t
=
tool
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
push
(
self
dest
=
None
rev
=
None
force
=
False
bookmark
=
None
branch
=
None
             
newbranch
=
False
ssh
=
None
remotecmd
=
None
insecure
=
False
)
:
        
"
"
"
Push
changesets
from
this
repository
to
the
specified
destination
.
        
This
operation
is
symmetrical
to
pull
:
it
is
identical
to
a
pull
in
the
        
destination
repository
from
the
current
one
.
        
Returns
True
if
push
was
successful
False
if
nothing
to
push
.
        
rev
-
the
(
list
of
)
specified
revision
and
all
its
ancestors
        
will
be
pushed
to
the
remote
repository
.
        
force
-
override
the
default
behavior
and
push
all
changesets
on
all
        
branches
.
        
bookmark
-
(
list
of
)
bookmark
to
push
        
branch
-
a
(
list
of
)
specific
branch
you
would
like
to
push
        
newbranch
-
allows
push
to
create
a
new
named
branch
that
is
         
not
present
at
the
destination
.
This
allows
you
to
only
create
         
a
new
branch
without
forcing
other
changes
.
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
         
web
.
cacerts
config
)
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
push
'
)
dest
r
=
rev
f
=
force
B
=
bookmark
b
=
branch
                          
new_branch
=
newbranch
e
=
ssh
remotecmd
=
remotecmd
                          
insecure
=
insecure
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
remove
(
self
files
after
=
False
force
=
False
include
=
None
               
exclude
=
None
)
:
        
"
"
"
Schedule
the
indicated
files
for
removal
from
the
repository
.
This
        
only
removes
files
from
the
current
branch
not
from
the
        
entire
project
history
.
        
Returns
True
on
success
False
if
any
warnings
encountered
.
        
after
-
used
to
remove
only
files
that
have
already
been
deleted
        
force
-
remove
(
and
delete
)
file
even
if
added
or
modified
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
remove
'
)
A
=
after
f
=
force
I
=
include
X
=
exclude
                          
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
resolve
(
self
file
=
[
]
all
=
False
listfiles
=
False
mark
=
False
                
unmark
=
False
tool
=
None
include
=
None
exclude
=
None
)
:
        
"
"
"
        
Redo
merges
or
set
/
view
the
merge
status
of
given
files
.
        
Returns
True
on
success
False
if
any
files
fail
a
resolve
attempt
.
        
When
listfiles
is
True
returns
a
list
of
(
code
file
path
)
of
resolved
        
and
unresolved
files
.
Code
will
be
'
R
'
or
'
U
'
accordingly
.
        
all
-
select
all
unresolved
files
        
mark
-
mark
files
as
resolved
        
unmark
-
mark
files
as
unresolved
        
tool
-
specify
merge
tool
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
file
list
)
:
            
file
=
[
file
]
        
args
=
cmdbuilder
(
b
(
'
resolve
'
)
a
=
all
l
=
listfiles
m
=
mark
u
=
unmark
                          
t
=
tool
I
=
include
X
=
exclude
*
file
)
        
out
=
self
.
rawcommand
(
args
)
        
if
listfiles
:
            
l
=
[
]
            
for
line
in
out
.
splitlines
(
)
:
                
l
.
append
(
tuple
(
line
.
split
(
b
(
'
'
)
1
)
)
)
            
return
l
    
def
revert
(
self
files
rev
=
None
all
=
False
date
=
None
nobackup
=
False
               
dryrun
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
With
no
revision
specified
revert
the
specified
files
or
        
directories
to
the
contents
they
had
in
the
parent
of
the
        
working
directory
.
This
restores
the
contents
of
files
to
an
        
unmodified
state
and
unschedules
adds
removes
copies
and
        
renames
.
If
the
working
directory
has
two
parents
you
must
        
explicitly
specify
a
revision
.
        
Specifying
rev
or
date
will
revert
the
given
files
or
        
directories
to
their
states
as
of
a
specific
revision
.
Because
        
revert
does
not
change
the
working
directory
parents
this
        
will
cause
these
files
to
appear
modified
.
This
can
be
helpful
        
to
"
back
out
"
some
or
all
of
an
earlier
change
.
        
Modified
files
are
saved
with
a
.
orig
suffix
before
reverting
.
        
To
disable
these
backups
use
nobackup
.
        
Returns
True
on
success
.
        
all
-
revert
all
changes
when
no
arguments
given
        
date
-
tipmost
revision
matching
date
        
rev
-
revert
to
the
specified
revision
        
nobackup
-
do
not
save
backup
copies
of
files
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
dryrun
-
do
not
perform
actions
just
print
output
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
revert
'
)
r
=
rev
a
=
all
d
=
date
                          
no_backup
=
nobackup
n
=
dryrun
I
=
include
X
=
exclude
                          
hidden
=
self
.
hidden
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
root
(
self
)
:
        
"
"
"
        
Return
the
root
directory
of
the
current
repository
.
        
"
"
"
        
return
self
.
rawcommand
(
[
b
(
'
root
'
)
]
)
.
rstrip
(
)
    
def
status
(
self
rev
=
None
change
=
None
all
=
False
modified
=
False
               
added
=
False
removed
=
False
deleted
=
False
clean
=
False
               
unknown
=
False
ignored
=
False
copies
=
False
               
subrepos
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
        
Return
status
of
files
in
the
repository
as
a
list
of
(
code
file
path
)
        
where
code
can
be
:
                
M
=
modified
                
A
=
added
                
R
=
removed
                
C
=
clean
                
!
=
missing
(
deleted
by
non
-
hg
command
but
still
tracked
)
                
?
=
untracked
                
I
=
ignored
                  
=
origin
of
the
previous
file
listed
as
A
(
added
)
        
rev
-
show
difference
from
(
list
of
)
revision
        
change
-
list
the
changed
files
of
a
revision
        
all
-
show
status
of
all
files
        
modified
-
show
only
modified
files
        
added
-
show
only
added
files
        
removed
-
show
only
removed
files
        
deleted
-
show
only
deleted
(
but
tracked
)
files
        
clean
-
show
only
files
without
changes
        
unknown
-
show
only
unknown
(
not
tracked
)
files
        
ignored
-
show
only
ignored
files
        
copies
-
show
source
of
copied
files
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
rev
and
change
:
            
raise
ValueError
(
'
cannot
specify
both
rev
and
change
'
)
        
args
=
cmdbuilder
(
b
(
'
status
'
)
rev
=
rev
change
=
change
A
=
all
                          
m
=
modified
a
=
added
r
=
removed
d
=
deleted
c
=
clean
                          
u
=
unknown
i
=
ignored
C
=
copies
S
=
subrepos
I
=
include
                          
X
=
exclude
hidden
=
self
.
hidden
)
        
args
.
append
(
b
(
'
-
0
'
)
)
        
out
=
self
.
rawcommand
(
args
)
        
l
=
[
]
        
for
entry
in
out
.
split
(
b
(
'
\
0
'
)
)
:
            
if
entry
:
                
if
entry
[
0
:
1
]
=
=
b
(
'
'
)
:
                    
l
.
append
(
(
b
(
'
'
)
entry
[
2
:
]
)
)
                
else
:
                    
l
.
append
(
tuple
(
entry
.
split
(
b
(
'
'
)
1
)
)
)
        
return
l
    
def
tag
(
self
names
rev
=
None
message
=
None
force
=
False
local
=
False
            
remove
=
False
date
=
None
user
=
None
)
:
        
"
"
"
Add
one
or
more
tags
specified
by
names
for
the
current
or
given
        
revision
.
        
Changing
an
existing
tag
is
normally
disallowed
;
use
force
to
override
.
        
Tag
commits
are
usually
made
at
the
head
of
a
branch
.
If
the
        
parent
of
the
working
directory
is
not
a
branch
head
a
        
CommandError
will
be
raised
.
force
can
be
specified
to
force
        
the
tag
commit
to
be
based
on
a
non
-
head
changeset
.
        
local
-
make
the
tag
local
        
rev
-
revision
to
tag
        
remove
-
remove
a
tag
        
message
-
set
commit
message
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
"
"
"
        
if
not
isinstance
(
names
list
)
:
            
names
=
[
names
]
        
args
=
cmdbuilder
(
b
(
'
tag
'
)
r
=
rev
m
=
message
f
=
force
l
=
local
                          
remove
=
remove
d
=
date
u
=
user
hidden
=
self
.
hidden
                          
*
names
)
        
self
.
rawcommand
(
args
)
    
def
tags
(
self
)
:
        
"
"
"
        
Return
a
list
of
repository
tags
as
:
(
name
rev
node
islocal
)
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
tags
'
)
v
=
True
)
        
out
=
self
.
rawcommand
(
args
)
        
t
=
[
]
        
for
line
in
out
.
splitlines
(
)
:
            
taglocal
=
line
.
endswith
(
b
(
'
local
'
)
)
            
if
taglocal
:
                
line
=
line
[
:
-
6
]
            
name
rev
=
line
.
rsplit
(
b
(
'
'
)
1
)
            
rev
node
=
rev
.
split
(
b
(
'
:
'
)
)
            
t
.
append
(
(
name
.
rstrip
(
)
int
(
rev
)
node
taglocal
)
)
        
return
t
    
def
phase
(
self
revs
=
(
)
secret
=
False
draft
=
False
public
=
False
              
force
=
False
)
:
        
'
'
'
Set
or
show
the
current
phase
name
.
        
revs
-
target
revision
(
s
)
        
public
-
set
changeset
phase
to
public
        
draft
-
set
changeset
phase
to
draft
        
secret
-
set
changeset
phase
to
secret
        
force
-
allow
to
move
boundary
backward
        
output
format
:
[
(
id
phase
)
.
.
.
]
for
each
changeset
        
The
arguments
match
the
mercurial
API
.
        
'
'
'
        
if
not
isinstance
(
revs
(
list
tuple
)
)
:
            
revs
=
[
revs
]
        
args
=
util
.
cmdbuilder
(
b
(
'
phase
'
)
secret
=
secret
draft
=
draft
                               
public
=
public
force
=
force
                               
hidden
=
self
.
hidden
*
revs
)
        
out
=
self
.
rawcommand
(
args
)
        
if
draft
or
public
or
secret
:
            
return
        
else
:
            
output
=
[
i
.
split
(
b
(
'
:
'
)
)
for
i
in
out
.
strip
(
)
.
split
(
b
(
'
\
n
'
)
)
]
            
return
[
(
int
(
num
)
phase
)
for
(
num
phase
)
in
output
]
    
def
summary
(
self
remote
=
False
)
:
        
"
"
"
        
Return
a
dictionary
with
a
brief
summary
of
the
working
directory
state
        
including
parents
branch
commit
status
and
available
updates
.
            
'
parent
'
:
a
list
of
(
rev
node
tags
message
)
            
'
branch
'
:
the
current
branch
            
'
commit
'
:
True
if
the
working
directory
is
clean
False
otherwise
            
'
update
'
:
number
of
available
updates
            
[
'
remote
'
:
(
in
in
bookmarks
out
out
bookmarks
)
]
            
[
'
mq
'
:
(
applied
unapplied
)
mq
patches
]
            
unparsed
entries
will
be
of
them
form
key
:
value
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
summary
'
)
remote
=
remote
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
.
splitlines
(
)
        
d
=
{
}
        
while
out
:
            
line
=
out
.
pop
(
0
)
            
name
value
=
line
.
split
(
b
(
'
:
'
)
1
)
            
if
name
=
=
b
(
'
parent
'
)
:
                
parent
tags
=
value
.
split
(
b
(
'
'
)
1
)
                
rev
node
=
parent
.
split
(
b
(
'
:
'
)
)
                
if
tags
:
                    
tags
=
tags
.
replace
(
b
(
'
(
empty
repository
)
'
)
b
(
'
'
)
)
                
else
:
                    
tags
=
None
                
value
=
d
.
get
(
name
[
]
)
                
if
rev
=
=
b
(
'
-
1
'
)
:
                    
value
.
append
(
(
int
(
rev
)
node
tags
None
)
)
                
else
:
                    
message
=
out
.
pop
(
0
)
[
1
:
]
                    
value
.
append
(
(
int
(
rev
)
node
tags
message
)
)
            
elif
name
=
=
b
(
'
branch
'
)
:
                
pass
            
elif
name
=
=
b
(
'
commit
'
)
:
                
value
=
value
=
=
b
(
'
(
clean
)
'
)
            
elif
name
=
=
b
(
'
update
'
)
:
                
if
value
=
=
b
(
'
(
current
)
'
)
:
                    
value
=
0
                
else
:
                    
value
=
int
(
value
.
split
(
b
(
'
'
)
1
)
[
0
]
)
            
elif
remote
and
name
=
=
b
(
'
remote
'
)
:
                
if
value
=
=
b
(
'
(
synced
)
'
)
:
                    
value
=
0
0
0
0
                
else
:
                    
inc
=
incb
=
out_
=
outb
=
0
                    
for
v
in
value
.
split
(
b
(
'
'
)
)
:
                        
count
v
=
v
.
split
(
b
(
'
'
)
1
)
                        
if
v
=
=
b
(
'
outgoing
'
)
:
                            
out_
=
int
(
count
)
                        
elif
v
.
endswith
(
b
(
'
incoming
'
)
)
:
                            
inc
=
int
(
count
)
                        
elif
v
=
=
b
(
'
incoming
bookmarks
'
)
:
                            
incb
=
int
(
count
)
                        
elif
v
=
=
b
(
'
outgoing
bookmarks
'
)
:
                            
outb
=
int
(
count
)
                    
value
=
inc
incb
out_
outb
            
elif
name
=
=
b
(
'
mq
'
)
:
                
applied
=
unapplied
=
0
                
for
v
in
value
.
split
(
b
(
'
'
)
)
:
                    
count
v
=
v
.
split
(
b
(
'
'
)
1
)
                    
if
v
=
=
b
(
'
applied
'
)
:
                        
applied
=
int
(
count
)
                    
elif
v
=
=
b
(
'
unapplied
'
)
:
                        
unapplied
=
int
(
count
)
                
value
=
applied
unapplied
            
d
[
name
]
=
value
        
return
d
    
def
tip
(
self
)
:
        
"
"
"
        
Return
the
tip
revision
(
usually
just
called
the
tip
)
which
is
the
        
changeset
most
recently
added
to
the
repository
(
and
therefore
the
most
        
recently
changed
head
)
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
tip
'
)
template
=
templates
.
changeset
                          
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
out
=
out
.
split
(
b
(
'
\
0
'
)
)
        
return
self
.
_parserevs
(
out
)
[
0
]
    
def
update
(
self
rev
=
None
clean
=
False
check
=
False
date
=
None
)
:
        
"
"
"
        
Update
the
repository
'
s
working
directory
to
changeset
specified
by
rev
.
        
If
rev
isn
'
t
specified
update
to
the
tip
of
the
current
named
branch
.
        
Return
the
number
of
files
(
updated
merged
removed
unresolved
)
        
clean
-
discard
uncommitted
changes
(
no
backup
)
        
check
-
update
across
branches
if
no
uncommitted
changes
        
date
-
tipmost
revision
matching
date
        
"
"
"
        
if
clean
and
check
:
            
raise
ValueError
(
'
clean
and
check
cannot
both
be
True
'
)
        
args
=
cmdbuilder
(
b
(
'
update
'
)
r
=
rev
C
=
clean
c
=
check
d
=
date
                          
hidden
=
self
.
hidden
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
=
=
1
:
                
return
out
            
raise
error
.
CommandError
(
args
ret
out
err
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
        
m
=
re
.
search
(
b
(
r
'
^
(
\
d
+
)
.
+
(
\
d
+
)
.
+
(
\
d
+
)
.
+
(
\
d
+
)
'
)
out
                      
re
.
MULTILINE
)
        
return
tuple
(
map
(
int
list
(
m
.
groups
(
)
)
)
)
    
property
    
def
version
(
self
)
:
        
"
"
"
Return
hg
version
that
runs
the
command
server
as
a
4
fielded
        
tuple
:
major
minor
micro
and
local
build
info
.
e
.
g
.
(
1
9
        
1
'
+
4
-
3095db9f5c2c
'
)
        
"
"
"
        
if
self
.
_version
is
None
:
            
v
=
self
.
rawcommand
(
cmdbuilder
(
b
(
'
version
'
)
q
=
True
)
)
            
v
=
list
(
re
.
match
(
b
(
r
'
.
*
?
(
\
d
+
)
\
.
(
\
d
+
)
\
.
?
(
\
d
+
)
?
(
\
+
[
0
-
9a
-
f
-
]
+
)
?
'
)
                              
v
)
.
groups
(
)
)
            
for
i
in
range
(
3
)
:
                
try
:
                    
v
[
i
]
=
int
(
v
[
i
]
)
                
except
TypeError
:
                    
v
[
i
]
=
0
            
self
.
_version
=
tuple
(
v
)
        
return
self
.
_version
    
def
__getitem__
(
self
changeid
)
:
        
try
:
            
return
context
.
changectx
(
self
changeid
)
        
except
ValueError
as
e
:
            
raise
KeyError
(
*
e
.
args
)
    
def
__contains__
(
self
changeid
)
:
        
"
"
"
        
check
if
changeid
which
can
be
either
a
local
revision
number
or
a
        
changeset
id
matches
a
changeset
in
the
client
.
        
"
"
"
        
try
:
            
context
.
changectx
(
self
changeid
)
            
return
True
        
except
ValueError
:
            
return
False

536d79a2f0ea2f5dfa6e5a71d87d70585228572f
import
struct
re
datetime
import
hglib
from
hglib
import
error
util
templates
merge
context
from
hglib
.
util
import
b
cmdbuilder
BytesIO
strtobytes
class
revision
(
tuple
)
:
    
def
__new__
(
cls
rev
node
tags
branch
author
desc
date
)
:
        
return
tuple
.
__new__
(
cls
(
rev
node
tags
branch
author
desc
date
)
)
    
property
    
def
rev
(
self
)
:
        
return
self
[
0
]
    
property
    
def
node
(
self
)
:
        
return
self
[
1
]
    
property
    
def
tags
(
self
)
:
        
return
self
[
2
]
    
property
    
def
branch
(
self
)
:
        
return
self
[
3
]
    
property
    
def
author
(
self
)
:
        
return
self
[
4
]
    
property
    
def
desc
(
self
)
:
        
return
self
[
5
]
    
property
    
def
date
(
self
)
:
        
return
self
[
6
]
class
hgclient
(
object
)
:
    
inputfmt
=
'
>
I
'
    
outputfmt
=
'
>
cI
'
    
outputfmtsize
=
struct
.
calcsize
(
outputfmt
)
    
retfmt
=
'
>
i
'
    
def
__init__
(
self
path
encoding
configs
connect
=
True
)
:
        
self
.
_args
=
[
hglib
.
HGPATH
'
serve
'
'
-
-
cmdserver
'
'
pipe
'
                
'
-
-
config
'
'
ui
.
interactive
=
True
'
]
        
if
path
:
            
self
.
_args
+
=
[
'
-
R
'
path
]
        
if
configs
:
            
for
config
in
configs
:
                
self
.
_args
+
=
[
'
-
-
config
'
config
]
        
self
.
_env
=
{
'
HGPLAIN
'
:
'
1
'
}
        
if
encoding
:
            
self
.
_env
[
'
HGENCODING
'
]
=
encoding
        
self
.
server
=
None
        
self
.
_version
=
None
        
#
include
the
hidden
changesets
if
True
        
self
.
hidden
=
None
        
self
.
_cbout
=
None
        
self
.
_cberr
=
None
        
self
.
_cbprompt
=
None
        
if
connect
:
            
self
.
open
(
)
        
self
.
_protocoltracefn
=
None
    
def
setcbout
(
self
cbout
)
:
        
"
"
"
        
cbout
is
a
function
that
will
be
called
with
the
stdout
data
of
        
the
command
as
it
runs
.
Call
with
None
to
stop
getting
call
backs
.
        
"
"
"
        
self
.
_cbout
=
cbout
    
def
setcberr
(
self
cberr
)
:
        
"
"
"
        
cberr
is
a
function
that
will
be
called
with
the
stderr
data
of
        
the
command
as
it
runs
.
Call
with
None
to
stop
getting
call
backs
.
        
"
"
"
        
self
.
_cberr
=
cberr
    
def
setcbprompt
(
self
cbprompt
)
:
        
"
"
"
        
cbprompt
is
used
to
reply
to
prompts
by
the
server
        
It
receives
the
max
number
of
bytes
to
return
and
the
        
contents
of
stdout
received
so
far
.
        
Call
with
None
to
stop
getting
call
backs
.
        
cbprompt
is
never
called
from
merge
(
)
or
import_
(
)
        
which
already
handle
the
prompt
.
        
"
"
"
        
self
.
_cbprompt
=
cbprompt
    
def
setprotocoltrace
(
self
tracefn
=
None
)
:
        
"
"
"
        
if
tracefn
is
None
no
trace
calls
will
be
made
.
        
Otherwise
tracefn
is
call
as
tracefn
(
direction
channel
data
)
        
direction
is
'
r
'
for
read
from
server
and
'
w
'
for
write
to
server
        
channel
is
always
None
when
direction
is
'
w
'
        
and
the
channel
-
identified
when
the
direction
is
'
r
'
        
"
"
"
        
self
.
_protocoltracefn
=
tracefn
    
def
__enter__
(
self
)
:
        
if
self
.
server
is
None
:
            
self
.
open
(
)
        
return
self
    
def
__exit__
(
self
exc_type
exc_val
exc_tb
)
:
        
self
.
close
(
)
    
def
_readhello
(
self
)
:
        
"
"
"
read
the
hello
message
the
server
sends
when
started
"
"
"
        
ch
msg
=
self
.
_readchannel
(
)
        
assert
ch
=
=
b
(
'
o
'
)
        
msg
=
msg
.
split
(
b
(
'
\
n
'
)
)
        
self
.
capabilities
=
msg
[
0
]
[
len
(
b
(
'
capabilities
:
'
)
)
:
]
        
if
not
self
.
capabilities
:
            
raise
error
.
ResponseError
(
                
"
bad
hello
message
:
expected
'
capabilities
:
'
"
                
"
got
%
r
"
%
msg
[
0
]
)
        
self
.
capabilities
=
set
(
self
.
capabilities
.
split
(
)
)
        
#
at
the
very
least
the
server
should
be
able
to
run
commands
        
assert
b
(
'
runcommand
'
)
in
self
.
capabilities
        
self
.
_encoding
=
msg
[
1
]
[
len
(
b
(
'
encoding
:
'
)
)
:
]
        
if
not
self
.
_encoding
:
            
raise
error
.
ResponseError
(
"
bad
hello
message
:
expected
'
encoding
:
'
"
                                      
"
got
%
r
"
%
msg
[
1
]
)
    
def
_readchannel
(
self
)
:
        
data
=
self
.
server
.
stdout
.
read
(
hgclient
.
outputfmtsize
)
        
if
not
data
:
            
raise
error
.
ServerError
(
)
        
channel
length
=
struct
.
unpack
(
hgclient
.
outputfmt
data
)
        
if
channel
in
b
(
'
IL
'
)
:
            
return
channel
length
        
else
:
            
return
channel
self
.
server
.
stdout
.
read
(
length
)
    
staticmethod
    
def
_parserevs
(
splitted
)
:
        
'
'
'
splitted
is
a
list
of
fields
according
to
our
rev
.
style
where
        
each
6
fields
compose
one
revision
.
        
'
'
'
        
revs
=
[
]
        
for
rev
in
util
.
grouper
(
7
splitted
)
:
            
#
truncate
the
timezone
and
convert
to
a
local
datetime
            
posixtime
=
float
(
rev
[
6
]
.
split
(
b
(
'
.
'
)
1
)
[
0
]
)
            
dt
=
datetime
.
datetime
.
fromtimestamp
(
posixtime
)
            
revs
.
append
(
revision
(
rev
[
0
]
rev
[
1
]
rev
[
2
]
rev
[
3
]
                                 
rev
[
4
]
rev
[
5
]
dt
)
)
        
return
revs
    
def
runcommand
(
self
args
inchannels
outchannels
)
:
        
def
writeblock
(
data
)
:
            
if
self
.
_protocoltracefn
is
not
None
:
                
self
.
_protocoltracefn
(
'
w
'
None
data
)
            
self
.
server
.
stdin
.
write
(
struct
.
pack
(
self
.
inputfmt
len
(
data
)
)
)
            
self
.
server
.
stdin
.
write
(
data
)
            
self
.
server
.
stdin
.
flush
(
)
        
if
not
self
.
server
:
            
raise
ValueError
(
"
server
not
connected
"
)
        
self
.
server
.
stdin
.
write
(
b
(
'
runcommand
\
n
'
)
)
        
writeblock
(
b
(
'
\
0
'
)
.
join
(
args
)
)
        
while
True
:
            
channel
data
=
self
.
_readchannel
(
)
            
if
self
.
_protocoltracefn
is
not
None
:
                
self
.
_protocoltracefn
(
'
r
'
channel
data
)
            
#
input
channels
            
if
channel
in
inchannels
:
                
writeblock
(
inchannels
[
channel
]
(
data
)
)
            
#
output
channels
            
elif
channel
in
outchannels
:
                
outchannels
[
channel
]
(
data
)
            
#
result
channel
command
finished
            
elif
channel
=
=
b
(
'
r
'
)
:
                
return
struct
.
unpack
(
hgclient
.
retfmt
data
)
[
0
]
            
#
a
channel
that
we
don
'
t
know
and
can
'
t
ignore
            
elif
channel
.
isupper
(
)
:
                
raise
error
.
ResponseError
(
                    
"
unexpected
data
on
required
channel
'
%
s
'
"
%
channel
)
            
#
optional
channel
            
else
:
                
pass
    
def
rawcommand
(
self
args
eh
=
None
prompt
=
None
input
=
None
)
:
        
"
"
"
        
args
is
the
cmdline
(
usually
built
using
util
.
cmdbuilder
)
        
eh
is
an
error
handler
that
is
passed
the
return
code
stdout
and
stderr
        
If
no
eh
is
given
we
raise
a
CommandError
if
ret
!
=
0
        
prompt
is
used
to
reply
to
prompts
by
the
server
        
It
receives
the
max
number
of
bytes
to
return
and
the
contents
of
stdout
        
received
so
far
        
input
is
used
to
reply
to
bulk
data
requests
by
the
server
        
It
receives
the
max
number
of
bytes
to
return
        
"
"
"
        
out
err
=
BytesIO
(
)
BytesIO
(
)
        
outchannels
=
{
}
        
if
self
.
_cbout
is
None
:
            
outchannels
[
b
(
'
o
'
)
]
=
out
.
write
        
else
:
            
def
out_handler
(
data
)
:
                
out
.
write
(
data
)
                
self
.
_cbout
(
data
)
            
outchannels
[
b
(
'
o
'
)
]
=
out_handler
        
if
self
.
_cberr
is
None
:
            
outchannels
[
b
(
'
e
'
)
]
=
err
.
write
        
else
:
            
def
err_handler
(
data
)
:
                
err
.
write
(
data
)
                
self
.
_cberr
(
data
)
            
outchannels
[
b
(
'
e
'
)
]
=
err_handler
        
inchannels
=
{
}
        
if
prompt
is
None
:
            
prompt
=
self
.
_cbprompt
        
if
prompt
is
not
None
:
            
def
func
(
size
)
:
                
reply
=
prompt
(
size
out
.
getvalue
(
)
)
                
return
reply
            
inchannels
[
b
(
'
L
'
)
]
=
func
        
if
input
is
not
None
:
            
inchannels
[
b
(
'
I
'
)
]
=
input
        
ret
=
self
.
runcommand
(
args
inchannels
outchannels
)
        
out
err
=
out
.
getvalue
(
)
err
.
getvalue
(
)
        
if
ret
:
            
if
eh
is
None
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
            
else
:
                
return
eh
(
ret
out
err
)
        
return
out
    
def
open
(
self
)
:
        
if
self
.
server
is
not
None
:
            
raise
ValueError
(
'
server
already
open
'
)
        
self
.
server
=
util
.
popen
(
self
.
_args
self
.
_env
)
        
try
:
            
self
.
_readhello
(
)
        
except
error
.
ServerError
:
            
ret
serr
=
self
.
_close
(
)
            
raise
error
.
ServerError
(
'
server
exited
with
status
%
d
:
%
s
'
                                    
%
(
ret
serr
.
strip
(
)
)
)
        
return
self
    
def
close
(
self
)
:
        
"
"
"
Closes
the
command
server
instance
and
waits
for
it
to
exit
        
returns
the
exit
code
.
        
Attempting
to
call
any
function
afterwards
that
needs
to
        
communicate
with
the
server
will
raise
a
ValueError
.
        
"
"
"
        
return
self
.
_close
(
)
[
0
]
    
def
_close
(
self
)
:
        
_sout
serr
=
self
.
server
.
communicate
(
)
        
ret
=
self
.
server
.
returncode
        
self
.
server
=
None
        
return
ret
serr
    
def
add
(
self
files
=
[
]
dryrun
=
False
subrepos
=
False
include
=
None
            
exclude
=
None
)
:
        
"
"
"
        
Add
the
specified
files
on
the
next
commit
.
        
If
no
files
are
given
add
all
files
to
the
repository
.
        
dryrun
-
do
no
perform
actions
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
Return
whether
all
given
files
were
added
.
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
add
'
)
n
=
dryrun
S
=
subrepos
I
=
include
X
=
exclude
                          
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
addremove
(
self
files
=
[
]
similarity
=
None
dryrun
=
False
include
=
None
                  
exclude
=
None
)
:
        
"
"
"
Add
all
new
files
and
remove
all
missing
files
from
the
repository
.
        
New
files
are
ignored
if
they
match
any
of
the
patterns
in
        
"
.
hgignore
"
.
As
with
add
these
changes
take
effect
at
the
        
next
commit
.
        
similarity
-
used
to
detect
renamed
files
.
With
a
parameter
        
greater
than
0
this
compares
every
removed
file
with
every
        
added
file
and
records
those
similar
enough
as
renames
.
This
        
option
takes
a
percentage
between
0
(
disabled
)
and
100
(
files
        
must
be
identical
)
as
its
parameter
.
Detecting
renamed
files
        
this
way
can
be
expensive
.
After
using
this
option
"
hg
status
        
-
C
"
can
be
used
to
check
which
files
were
identified
as
moved
        
or
renamed
.
        
dryrun
-
do
no
perform
actions
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
Return
True
if
all
files
are
successfully
added
.
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
addremove
'
)
s
=
similarity
n
=
dryrun
I
=
include
                          
X
=
exclude
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
annotate
(
self
files
rev
=
None
nofollow
=
False
text
=
False
user
=
False
                 
file
=
False
date
=
False
number
=
False
changeset
=
False
                 
line
=
False
verbose
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
        
Show
changeset
information
by
line
for
each
file
in
files
.
        
rev
-
annotate
the
specified
revision
        
nofollow
-
don
'
t
follow
copies
and
renames
        
text
-
treat
all
files
as
text
        
user
-
list
the
author
(
long
with
-
v
)
        
file
-
list
the
filename
        
date
-
list
the
date
        
number
-
list
the
revision
number
(
default
)
        
changeset
-
list
the
changeset
        
line
-
show
line
number
at
the
first
appearance
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
Yields
a
(
info
contents
)
tuple
for
each
line
in
a
file
.
Info
is
a
space
        
separated
string
according
to
the
given
options
.
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
annotate
'
)
r
=
rev
no_follow
=
nofollow
a
=
text
                          
u
=
user
f
=
file
d
=
date
n
=
number
c
=
changeset
                          
l
=
line
v
=
verbose
I
=
include
X
=
exclude
                          
hidden
=
self
.
hidden
*
files
)
        
out
=
self
.
rawcommand
(
args
)
        
for
line
in
out
.
splitlines
(
)
:
            
yield
tuple
(
line
.
split
(
b
(
'
:
'
)
1
)
)
    
def
archive
(
self
dest
rev
=
None
nodecode
=
False
prefix
=
None
type
=
None
                
subrepos
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
Create
an
unversioned
archive
of
a
repository
revision
.
        
The
exact
name
of
the
destination
archive
or
directory
is
given
using
a
        
format
string
;
see
export
for
details
.
        
Each
member
added
to
an
archive
file
has
a
directory
prefix
        
prepended
.
Use
prefix
to
specify
a
format
string
for
the
        
prefix
.
The
default
is
the
basename
of
the
archive
with
        
suffixes
removed
.
        
dest
-
destination
path
        
rev
-
revision
to
distribute
.
The
revision
used
is
the
parent
of
the
        
working
directory
if
one
isn
'
t
given
.
        
nodecode
-
do
not
pass
files
through
decoders
        
prefix
-
directory
prefix
for
files
in
archive
        
type
-
type
of
distribution
to
create
.
The
archive
type
is
automatically
        
detected
based
on
file
extension
if
one
isn
'
t
given
.
        
Valid
types
are
:
        
"
files
"
a
directory
full
of
files
(
default
)
        
"
tar
"
tar
archive
uncompressed
        
"
tbz2
"
tar
archive
compressed
using
bzip2
        
"
tgz
"
tar
archive
compressed
using
gzip
        
"
uzip
"
zip
archive
uncompressed
        
"
zip
"
zip
archive
compressed
using
deflate
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
archive
'
)
dest
r
=
rev
                          
no_decode
=
nodecode
p
=
prefix
                          
t
=
type
S
=
subrepos
I
=
include
X
=
exclude
                          
hidden
=
self
.
hidden
)
        
self
.
rawcommand
(
args
)
    
def
backout
(
self
rev
merge
=
False
parent
=
None
tool
=
None
message
=
None
                
logfile
=
None
date
=
None
user
=
None
)
:
        
"
"
"
Prepare
a
new
changeset
with
the
effect
of
rev
undone
in
the
current
        
working
directory
.
        
If
rev
is
the
parent
of
the
working
directory
then
this
new
        
changeset
is
committed
automatically
.
Otherwise
hg
needs
to
        
merge
the
changes
and
the
merged
result
is
left
uncommitted
.
        
rev
-
revision
to
backout
        
merge
-
merge
with
old
dirstate
parent
after
backout
        
parent
-
parent
to
choose
when
backing
out
merge
        
tool
-
specify
merge
tool
        
message
-
use
text
as
commit
message
        
logfile
-
read
commit
message
from
file
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
"
"
"
        
if
message
and
logfile
:
            
raise
ValueError
(
"
cannot
specify
both
a
message
and
a
logfile
"
)
        
args
=
cmdbuilder
(
b
(
'
backout
'
)
r
=
rev
merge
=
merge
parent
=
parent
                          
t
=
tool
m
=
message
l
=
logfile
d
=
date
u
=
user
                          
hidden
=
self
.
hidden
)
        
self
.
rawcommand
(
args
)
    
def
bookmark
(
self
name
rev
=
None
force
=
False
delete
=
False
                 
inactive
=
False
rename
=
None
)
:
        
"
"
"
        
Set
a
bookmark
on
the
working
directory
'
s
parent
revision
or
rev
        
with
the
given
name
.
        
name
-
bookmark
name
        
rev
-
revision
to
bookmark
        
force
-
bookmark
even
if
another
bookmark
with
the
same
name
exists
        
delete
-
delete
the
given
bookmark
        
inactive
-
do
not
mark
the
new
bookmark
active
        
rename
-
rename
the
bookmark
given
by
rename
to
name
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
bookmark
'
)
name
r
=
rev
f
=
force
d
=
delete
                          
i
=
inactive
m
=
rename
)
        
self
.
rawcommand
(
args
)
    
def
bookmarks
(
self
)
:
        
"
"
"
        
Return
the
bookmarks
as
a
list
of
(
name
rev
node
)
and
the
index
of
the
        
current
one
.
        
If
there
isn
'
t
a
current
one
-
1
is
returned
as
the
index
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
bookmarks
'
)
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
bms
=
[
]
        
current
=
-
1
        
if
out
.
rstrip
(
)
!
=
b
(
'
no
bookmarks
set
'
)
:
            
for
line
in
out
.
splitlines
(
)
:
                
iscurrent
line
=
line
[
0
:
3
]
line
[
3
:
]
                
if
b
(
'
*
'
)
in
iscurrent
:
                    
current
=
len
(
bms
)
                
name
line
=
line
.
split
(
b
(
'
'
)
1
)
                
rev
node
=
line
.
split
(
b
(
'
:
'
)
)
                
bms
.
append
(
(
name
int
(
rev
)
node
)
)
        
return
bms
current
    
def
branch
(
self
name
=
None
clean
=
False
force
=
False
)
:
        
"
"
"
When
name
isn
'
t
given
return
the
current
branch
name
.
Otherwise
        
set
the
working
directory
branch
name
(
the
branch
will
not
        
exist
in
the
repository
until
the
next
commit
)
.
Standard
        
practice
recommends
that
primary
development
take
place
on
the
        
'
default
'
branch
.
        
When
clean
is
True
reset
and
return
the
working
directory
        
branch
to
that
of
the
parent
of
the
working
directory
        
negating
a
previous
branch
change
.
        
name
-
new
branch
name
        
clean
-
reset
branch
name
to
parent
branch
name
        
force
-
set
branch
name
even
if
it
shadows
an
existing
branch
        
"
"
"
        
if
name
and
clean
:
            
raise
ValueError
(
'
cannot
use
both
name
and
clean
'
)
        
args
=
cmdbuilder
(
b
(
'
branch
'
)
name
f
=
force
C
=
clean
)
        
out
=
self
.
rawcommand
(
args
)
.
rstrip
(
)
        
if
name
:
            
return
name
        
elif
not
clean
:
            
return
out
        
else
:
            
#
len
(
'
reset
working
directory
to
branch
'
)
=
=
34
            
return
out
[
34
:
]
    
def
branches
(
self
active
=
False
closed
=
False
)
:
        
"
"
"
        
Returns
the
repository
'
s
named
branches
as
a
list
of
(
name
rev
node
)
.
        
active
-
show
only
branches
that
have
unmerged
heads
        
closed
-
show
normal
and
closed
branches
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
branches
'
)
a
=
active
c
=
closed
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
branches
=
[
]
        
for
line
in
out
.
rstrip
(
)
.
splitlines
(
)
:
            
namerev
node
=
line
.
rsplit
(
b
(
'
:
'
)
1
)
            
name
rev
=
namerev
.
rsplit
(
b
(
'
'
)
1
)
            
name
=
name
.
rstrip
(
)
            
node
=
node
.
split
(
)
[
0
]
#
get
rid
of
'
(
inactive
)
'
            
branches
.
append
(
(
name
int
(
rev
)
node
)
)
        
return
branches
    
def
bundle
(
self
file
destrepo
=
None
rev
=
[
]
branch
=
[
]
base
=
[
]
all
=
False
               
force
=
False
type
=
None
ssh
=
None
remotecmd
=
None
               
insecure
=
False
)
:
        
"
"
"
Generate
a
compressed
changegroup
file
collecting
changesets
not
        
known
to
be
in
another
repository
.
        
If
destrepo
isn
'
t
given
then
hg
assumes
the
destination
will
have
all
        
the
nodes
you
specify
with
base
.
To
create
a
bundle
containing
all
        
changesets
use
all
(
or
set
base
to
'
null
'
)
.
        
file
-
destination
file
name
        
destrepo
-
repository
to
look
for
changes
        
rev
-
a
changeset
intended
to
be
added
to
the
destination
        
branch
-
a
specific
branch
you
would
like
to
bundle
        
base
-
a
base
changeset
assumed
to
be
available
at
the
destination
        
all
-
bundle
all
changesets
in
the
repository
        
type
-
bundle
compression
type
to
use
available
compression
         
methods
are
:
none
bzip2
and
gzip
(
default
:
bzip2
)
        
force
-
run
even
when
the
destrepo
is
unrelated
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
         
web
.
cacerts
config
)
        
Return
True
if
a
bundle
was
created
False
if
no
changes
were
found
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
bundle
'
)
file
destrepo
f
=
force
r
=
rev
b
=
branch
                          
base
=
base
a
=
all
t
=
type
e
=
ssh
remotecmd
=
remotecmd
                          
insecure
=
insecure
hidden
=
self
.
hidden
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
cat
(
self
files
rev
=
None
output
=
None
)
:
        
"
"
"
Return
a
string
containing
the
specified
files
as
they
were
at
the
        
given
revision
.
If
no
revision
is
given
the
parent
of
the
working
        
directory
is
used
or
tip
if
no
revision
is
checked
out
.
        
If
output
is
given
writes
the
contents
to
the
specified
file
.
        
The
name
of
the
file
is
given
using
a
format
string
.
The
        
formatting
rules
are
the
same
as
for
the
export
command
with
        
the
following
additions
:
        
"
%
s
"
basename
of
file
being
printed
        
"
%
d
"
dirname
of
file
being
printed
or
'
.
'
if
in
repository
root
        
"
%
p
"
root
-
relative
path
name
of
file
being
printed
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
cat
'
)
r
=
rev
o
=
output
hidden
=
self
.
hidden
*
files
)
        
out
=
self
.
rawcommand
(
args
)
        
if
not
output
:
            
return
out
    
def
clone
(
self
source
=
b
(
'
.
'
)
dest
=
None
branch
=
None
updaterev
=
None
              
revrange
=
None
)
:
        
"
"
"
        
Create
a
copy
of
an
existing
repository
specified
by
source
in
a
new
        
directory
dest
.
        
If
dest
isn
'
t
specified
it
defaults
to
the
basename
of
source
.
        
branch
-
clone
only
the
specified
branch
        
updaterev
-
revision
tag
or
branch
to
check
out
        
revrange
-
include
the
specified
changeset
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
clone
'
)
source
dest
b
=
branch
                          
u
=
updaterev
r
=
revrange
)
        
self
.
rawcommand
(
args
)
    
def
init
(
self
dest
ssh
=
None
remotecmd
=
None
insecure
=
False
)
:
        
args
=
util
.
cmdbuilder
(
'
init
'
dest
e
=
ssh
remotecmd
=
remotecmd
                               
insecure
=
insecure
)
        
self
.
rawcommand
(
args
)
    
def
commit
(
self
message
=
None
logfile
=
None
addremove
=
False
               
closebranch
=
False
date
=
None
user
=
None
include
=
None
               
exclude
=
None
amend
=
False
)
:
        
"
"
"
        
Commit
changes
reported
by
status
into
the
repository
.
        
message
-
the
commit
message
        
logfile
-
read
commit
message
from
file
        
addremove
-
mark
new
/
missing
files
as
added
/
removed
before
committing
        
closebranch
-
mark
a
branch
as
closed
hiding
it
from
the
branch
list
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
amend
-
amend
the
parent
of
the
working
dir
        
"
"
"
        
if
amend
and
message
is
None
and
logfile
is
None
:
            
#
retrieve
current
commit
message
            
message
=
self
.
log
(
b
(
'
.
'
)
)
[
0
]
[
5
]
        
if
message
is
None
and
logfile
is
None
and
not
amend
:
            
raise
ValueError
(
"
must
provide
at
least
a
message
or
a
logfile
"
)
        
elif
message
and
logfile
:
            
raise
ValueError
(
"
cannot
specify
both
a
message
and
a
logfile
"
)
        
#
-
-
debug
will
print
the
committed
cset
        
args
=
cmdbuilder
(
b
(
'
commit
'
)
debug
=
True
m
=
message
A
=
addremove
                          
close_branch
=
closebranch
d
=
date
u
=
user
l
=
logfile
                          
I
=
include
X
=
exclude
amend
=
amend
)
        
out
=
self
.
rawcommand
(
args
)
        
m
=
re
.
search
(
b
(
r
'
^
committed
changeset
(
\
d
+
)
:
(
[
0
-
9a
-
f
]
+
)
'
)
out
                      
re
.
MULTILINE
)
        
if
not
m
:
            
raise
ValueError
(
'
revision
and
node
not
found
in
hg
output
:
%
r
'
                             
%
out
)
        
rev
node
=
m
.
groups
(
)
        
return
int
(
rev
)
node
    
def
config
(
self
names
=
[
]
untrusted
=
False
showsource
=
False
)
:
        
"
"
"
Return
a
list
of
(
section
key
value
)
config
settings
from
all
        
hgrc
files
        
When
showsource
is
specified
return
(
source
section
key
value
)
where
        
source
is
of
the
form
filename
:
[
line
]
        
"
"
"
        
def
splitline
(
s
)
:
            
k
value
=
s
.
rstrip
(
)
.
split
(
b
(
'
=
'
)
1
)
            
section
key
=
k
.
split
(
b
(
'
.
'
)
1
)
            
return
section
key
value
        
if
not
isinstance
(
names
list
)
:
            
names
=
[
names
]
        
args
=
cmdbuilder
(
b
(
'
showconfig
'
)
u
=
untrusted
debug
=
showsource
                          
*
names
)
        
out
=
self
.
rawcommand
(
args
)
        
conf
=
[
]
        
if
showsource
:
            
out
=
util
.
skiplines
(
out
b
(
'
read
config
from
:
'
)
)
            
for
line
in
out
.
splitlines
(
)
:
                
m
=
re
.
match
(
b
(
r
"
(
.
+
?
:
(
?
:
\
d
+
:
)
?
)
(
.
*
)
"
)
line
)
                
t
=
splitline
(
m
.
group
(
2
)
)
                
conf
.
append
(
(
m
.
group
(
1
)
[
:
-
1
]
t
[
0
]
t
[
1
]
t
[
2
]
)
)
        
else
:
            
for
line
in
out
.
splitlines
(
)
:
                
conf
.
append
(
splitline
(
line
)
)
        
return
conf
    
property
    
def
encoding
(
self
)
:
        
"
"
"
        
Return
the
server
'
s
encoding
(
as
reported
in
the
hello
message
)
.
        
"
"
"
        
if
not
b
(
'
getencoding
'
)
in
self
.
capabilities
:
            
raise
CapabilityError
(
'
getencoding
'
)
        
if
not
self
.
_encoding
:
            
self
.
server
.
stdin
.
write
(
b
(
'
getencoding
\
n
'
)
)
            
self
.
_encoding
=
self
.
_readfromchannel
(
'
r
'
)
        
return
self
.
_encoding
    
def
copy
(
self
source
dest
after
=
False
force
=
False
dryrun
=
False
             
include
=
None
exclude
=
None
)
:
        
"
"
"
Mark
dest
as
having
copies
of
source
files
.
If
dest
is
a
        
directory
copies
are
put
in
that
directory
.
If
dest
is
a
        
file
then
source
must
be
a
string
.
        
Returns
True
on
success
False
if
errors
are
encountered
.
        
source
-
a
file
or
a
list
of
files
        
dest
-
a
destination
file
or
directory
        
after
-
record
a
copy
that
has
already
occurred
        
force
-
forcibly
copy
over
an
existing
managed
file
        
dryrun
-
do
not
perform
actions
just
print
output
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
source
list
)
:
            
source
=
[
source
]
        
source
.
append
(
dest
)
        
args
=
cmdbuilder
(
b
(
'
copy
'
)
A
=
after
f
=
force
n
=
dryrun
                          
I
=
include
X
=
exclude
*
source
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
diff
(
self
files
=
[
]
revs
=
[
]
change
=
None
text
=
False
             
git
=
False
nodates
=
False
showfunction
=
False
             
reverse
=
False
ignoreallspace
=
False
             
ignorespacechange
=
False
ignoreblanklines
=
False
             
unified
=
None
stat
=
False
subrepos
=
False
include
=
None
             
exclude
=
None
)
:
        
"
"
"
        
Return
differences
between
revisions
for
the
specified
files
.
        
revs
-
a
revision
or
a
list
of
two
revisions
to
diff
        
change
-
change
made
by
revision
        
text
-
treat
all
files
as
text
        
git
-
use
git
extended
diff
format
        
nodates
-
omit
dates
from
diff
headers
        
showfunction
-
show
which
function
each
change
is
in
        
reverse
-
produce
a
diff
that
undoes
the
changes
        
ignoreallspace
-
ignore
white
space
when
comparing
lines
        
ignorespacechange
-
ignore
changes
in
the
amount
of
white
space
        
ignoreblanklines
-
ignore
changes
whose
lines
are
all
blank
        
unified
-
number
of
lines
of
context
to
show
        
stat
-
output
diffstat
-
style
summary
of
changes
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
change
and
revs
:
            
raise
ValueError
(
'
cannot
specify
both
change
and
rev
'
)
        
args
=
cmdbuilder
(
b
(
'
diff
'
)
r
=
list
(
map
(
strtobytes
revs
)
)
c
=
change
                          
a
=
text
g
=
git
nodates
=
nodates
                          
p
=
showfunction
reverse
=
reverse
                          
w
=
ignoreallspace
b
=
ignorespacechange
                          
B
=
ignoreblanklines
U
=
unified
stat
=
stat
                          
S
=
subrepos
I
=
include
X
=
exclude
hidden
=
self
.
hidden
                          
*
files
)
        
return
self
.
rawcommand
(
args
)
    
def
export
(
self
revs
output
=
None
switchparent
=
False
               
text
=
False
git
=
False
nodates
=
False
)
:
        
"
"
"
Return
the
header
and
diffs
for
one
or
more
changesets
.
When
        
output
is
given
dumps
to
file
.
The
name
of
the
file
is
given
        
using
a
format
string
.
The
formatting
rules
are
as
follows
:
        
"
%
%
"
literal
"
%
"
character
        
"
%
H
"
changeset
hash
(
40
hexadecimal
digits
)
        
"
%
N
"
number
of
patches
being
generated
        
"
%
R
"
changeset
revision
number
        
"
%
b
"
basename
of
the
exporting
repository
        
"
%
h
"
short
-
form
changeset
hash
(
12
hexadecimal
digits
)
        
"
%
n
"
zero
-
padded
sequence
number
starting
at
1
        
"
%
r
"
zero
-
padded
changeset
revision
number
        
output
-
print
output
to
file
with
formatted
name
        
switchparent
-
diff
against
the
second
parent
        
rev
-
a
revision
or
list
of
revisions
to
export
        
text
-
treat
all
files
as
text
        
git
-
use
git
extended
diff
format
        
nodates
-
omit
dates
from
diff
headers
        
"
"
"
        
if
not
isinstance
(
revs
list
)
:
            
revs
=
[
revs
]
        
args
=
cmdbuilder
(
b
(
'
export
'
)
o
=
output
switch_parent
=
switchparent
                          
a
=
text
g
=
git
nodates
=
nodates
hidden
=
self
.
hidden
                          
*
revs
)
        
out
=
self
.
rawcommand
(
args
)
        
if
output
is
None
:
            
return
out
    
def
forget
(
self
files
include
=
None
exclude
=
None
)
:
        
"
"
"
Mark
the
specified
files
so
they
will
no
longer
be
tracked
after
        
the
next
commit
.
        
This
only
removes
files
from
the
current
branch
not
from
the
entire
        
project
history
and
it
does
not
delete
them
from
the
working
directory
.
        
Returns
True
on
success
.
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
forget
'
)
I
=
include
X
=
exclude
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
grep
(
self
pattern
files
=
[
]
all
=
False
text
=
False
follow
=
False
             
ignorecase
=
False
fileswithmatches
=
False
line
=
False
user
=
False
             
date
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
Search
for
a
pattern
in
specified
files
and
revisions
.
        
This
behaves
differently
than
Unix
grep
.
It
only
accepts
Python
/
Perl
        
regexps
.
It
searches
repository
history
not
the
working
directory
.
        
It
always
prints
the
revision
number
in
which
a
match
appears
.
        
Yields
(
filename
revision
[
line
[
match
status
[
user
        
[
date
[
match
]
]
]
]
]
)
per
match
depending
on
the
given
options
.
        
all
-
print
all
revisions
that
match
        
text
-
treat
all
files
as
text
        
follow
-
follow
changeset
history
or
file
history
across
         
copies
and
renames
        
ignorecase
-
ignore
case
when
matching
        
fileswithmatches
-
return
only
filenames
and
revisions
that
match
        
line
-
return
line
numbers
in
the
result
tuple
        
user
-
return
the
author
in
the
result
tuple
        
date
-
return
the
date
in
the
result
tuple
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
grep
'
)
all
=
all
a
=
text
f
=
follow
i
=
ignorecase
                          
l
=
fileswithmatches
n
=
line
u
=
user
d
=
date
                          
I
=
include
X
=
exclude
hidden
=
self
.
hidden
                          
*
[
pattern
]
+
files
)
        
args
.
append
(
b
(
'
-
0
'
)
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
            
return
b
(
'
'
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
.
split
(
b
(
'
\
0
'
)
)
        
fieldcount
=
3
        
if
user
:
            
fieldcount
+
=
1
        
if
date
:
            
fieldcount
+
=
1
        
if
line
:
            
fieldcount
+
=
1
        
if
all
:
            
fieldcount
+
=
1
        
if
fileswithmatches
:
            
fieldcount
-
=
1
        
return
util
.
grouper
(
fieldcount
out
)
    
def
heads
(
self
rev
=
[
]
startrev
=
[
]
topological
=
False
closed
=
False
)
:
        
"
"
"
Return
a
list
of
current
repository
heads
or
branch
heads
.
        
rev
-
return
only
branch
heads
on
the
branches
associated
with
        
the
specified
changesets
.
        
startrev
-
return
only
heads
which
are
descendants
of
the
given
revs
.
        
topological
-
named
branch
mechanics
will
be
ignored
and
only
changesets
        
without
children
will
be
shown
.
        
closed
-
normal
and
closed
branch
heads
.
        
"
"
"
        
if
not
isinstance
(
rev
list
)
:
            
rev
=
[
rev
]
        
args
=
cmdbuilder
(
b
(
'
heads
'
)
r
=
startrev
t
=
topological
c
=
closed
                          
template
=
templates
.
changeset
hidden
=
self
.
hidden
                          
*
rev
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
            
return
b
(
'
'
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
        
return
self
.
_parserevs
(
out
)
    
def
identify
(
self
rev
=
None
source
=
None
num
=
False
id
=
False
branch
=
False
                 
tags
=
False
bookmarks
=
False
)
:
        
"
"
"
Return
a
summary
string
identifying
the
repository
state
at
rev
        
using
one
or
two
parent
hash
identifiers
followed
by
a
"
+
"
if
        
the
working
directory
has
uncommitted
changes
the
branch
name
        
(
if
not
default
)
a
list
of
tags
and
a
list
of
bookmarks
.
        
When
rev
is
not
given
return
a
summary
string
of
the
current
        
state
of
the
repository
.
        
Specifying
source
as
a
repository
root
or
Mercurial
bundle
will
cause
        
lookup
to
operate
on
that
repository
/
bundle
.
        
num
-
show
local
revision
number
        
id
-
show
global
revision
id
        
branch
-
show
branch
        
tags
-
show
tags
        
bookmarks
-
show
bookmarks
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
identify
'
)
source
r
=
rev
n
=
num
i
=
id
                          
b
=
branch
t
=
tags
B
=
bookmarks
                          
hidden
=
self
.
hidden
)
        
return
self
.
rawcommand
(
args
)
    
def
import_
(
self
patches
strip
=
None
force
=
False
nocommit
=
False
                
bypass
=
False
exact
=
False
importbranch
=
False
message
=
None
                
date
=
None
user
=
None
similarity
=
None
)
:
        
"
"
"
Import
the
specified
patches
which
can
be
a
list
of
file
names
or
a
        
file
-
like
object
and
commit
them
individually
(
unless
nocommit
is
        
specified
)
.
        
strip
-
directory
strip
option
for
patch
.
This
has
the
same
        
meaning
as
the
corresponding
patch
option
(
default
:
1
)
        
force
-
skip
check
for
outstanding
uncommitted
changes
        
nocommit
-
don
'
t
commit
just
update
the
working
directory
        
bypass
-
apply
patch
without
touching
the
working
directory
        
exact
-
apply
patch
to
the
nodes
from
which
it
was
generated
        
importbranch
-
use
any
branch
information
in
patch
(
implied
by
exact
)
        
message
-
the
commit
message
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
similarity
-
guess
renamed
files
by
similarity
(
0
<
=
s
<
=
100
)
        
"
"
"
        
if
hasattr
(
patches
'
read
'
)
and
hasattr
(
patches
'
readline
'
)
:
            
patch
=
patches
            
def
readline
(
size
output
)
:
                
return
patch
.
readline
(
size
)
            
stdin
=
True
            
patches
=
(
)
            
prompt
=
readline
            
input
=
patch
.
read
        
else
:
            
stdin
=
False
            
prompt
=
None
            
input
=
None
        
args
=
cmdbuilder
(
b
(
'
import
'
)
strip
=
strip
force
=
force
                          
no_commit
=
nocommit
bypass
=
bypass
exact
=
exact
                          
import_branch
=
importbranch
message
=
message
                          
date
=
date
user
=
user
similarity
=
similarity
_
=
stdin
                          
*
patches
)
        
self
.
rawcommand
(
args
prompt
=
prompt
input
=
input
)
    
def
incoming
(
self
revrange
=
None
path
=
None
force
=
False
newest
=
False
                 
bundle
=
None
bookmarks
=
False
branch
=
None
limit
=
None
                 
nomerges
=
False
subrepos
=
False
)
:
        
"
"
"
Return
new
changesets
found
in
the
specified
path
or
the
default
pull
        
location
.
        
When
bookmarks
=
True
return
a
list
of
(
name
node
)
of
incoming
        
bookmarks
.
        
revrange
-
a
remote
changeset
or
list
of
changesets
intended
to
be
added
        
force
-
run
even
if
remote
repository
is
unrelated
        
newest
-
show
newest
record
first
        
bundle
-
avoid
downloading
the
changesets
twice
and
store
the
         
bundles
into
the
specified
file
.
        
bookmarks
-
compare
bookmarks
(
this
changes
the
return
value
)
        
branch
-
a
specific
branch
you
would
like
to
pull
        
limit
-
limit
number
of
changes
returned
        
nomerges
-
do
not
show
merges
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
web
.
cacerts
config
)
        
subrepos
-
recurse
into
subrepositories
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
incoming
'
)
path
                          
template
=
templates
.
changeset
r
=
revrange
                          
f
=
force
n
=
newest
bundle
=
bundle
                          
B
=
bookmarks
b
=
branch
l
=
limit
M
=
nomerges
                          
S
=
subrepos
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
        
if
not
out
:
            
return
[
]
        
out
=
util
.
eatlines
(
out
2
)
        
if
bookmarks
:
            
bms
=
[
]
            
for
line
in
out
.
splitlines
(
)
:
                
bms
.
append
(
tuple
(
line
.
split
(
)
)
)
            
return
bms
        
else
:
            
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
            
return
self
.
_parserevs
(
out
)
    
def
log
(
self
revrange
=
None
files
=
[
]
follow
=
False
            
followfirst
=
False
date
=
None
copies
=
False
keyword
=
None
            
removed
=
False
onlymerges
=
False
user
=
None
branch
=
None
            
prune
=
None
hidden
=
None
limit
=
None
nomerges
=
False
            
include
=
None
exclude
=
None
)
:
        
"
"
"
Return
the
revision
history
of
the
specified
files
or
the
entire
        
project
.
        
File
history
is
shown
without
following
rename
or
copy
history
of
files
.
        
Use
follow
with
a
filename
to
follow
history
across
renames
and
copies
.
        
follow
without
a
filename
will
only
show
ancestors
or
descendants
of
the
        
starting
revision
.
followfirst
only
follows
the
first
parent
of
merge
        
revisions
.
        
If
revrange
isn
'
t
specified
the
default
is
"
tip
:
0
"
unless
        
follow
is
set
in
which
case
the
working
directory
parent
is
        
used
as
the
starting
revision
.
        
The
returned
changeset
is
a
named
tuple
with
the
following
        
string
fields
:
            
-
rev
            
-
node
            
-
tags
(
space
delimited
)
            
-
branch
            
-
author
            
-
desc
        
follow
-
follow
changeset
history
or
file
history
across
         
copies
and
renames
        
followfirst
-
only
follow
the
first
parent
of
merge
changesets
        
date
-
show
revisions
matching
date
spec
        
copies
-
show
copied
files
        
keyword
-
do
case
-
insensitive
search
for
a
given
text
        
removed
-
include
revisions
where
files
were
removed
        
onlymerges
-
show
only
merges
        
user
-
revisions
committed
by
user
        
branch
-
show
changesets
within
the
given
named
branch
        
prune
-
do
not
display
revision
or
any
of
its
ancestors
        
hidden
-
show
hidden
changesets
        
limit
-
limit
number
of
changes
displayed
        
nomerges
-
do
not
show
merges
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
hidden
is
None
:
            
hidden
=
self
.
hidden
        
args
=
cmdbuilder
(
b
(
'
log
'
)
template
=
templates
.
changeset
                          
r
=
revrange
f
=
follow
follow_first
=
followfirst
                          
d
=
date
C
=
copies
k
=
keyword
removed
=
removed
                          
m
=
onlymerges
u
=
user
b
=
branch
P
=
prune
                          
l
=
limit
M
=
nomerges
I
=
include
X
=
exclude
                          
hidden
=
hidden
*
files
)
        
out
=
self
.
rawcommand
(
args
)
        
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
        
return
self
.
_parserevs
(
out
)
    
def
manifest
(
self
rev
=
None
all
=
False
)
:
        
"
"
"
Yields
(
nodeid
permission
executable
symlink
file
path
)
tuples
        
for
version
controlled
files
for
the
given
revision
.
If
no
        
revision
is
given
the
first
parent
of
the
working
directory
        
is
used
or
the
null
revision
if
no
revision
is
checked
out
.
        
When
all
is
True
all
files
from
all
revisions
are
yielded
        
(
just
the
name
)
.
This
includes
deleted
and
renamed
files
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
manifest
'
)
r
=
rev
all
=
all
debug
=
True
                          
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
if
all
:
            
for
line
in
out
.
splitlines
(
)
:
                
yield
line
        
else
:
            
for
line
in
out
.
splitlines
(
)
:
                
node
=
line
[
0
:
40
]
                
perm
=
line
[
41
:
44
]
                
symlink
=
line
[
45
:
46
]
=
=
b
(
'
'
)
                
executable
=
line
[
45
:
46
]
=
=
b
(
'
*
'
)
                
yield
node
perm
executable
symlink
line
[
47
:
]
    
def
merge
(
self
rev
=
None
force
=
False
tool
=
None
cb
=
merge
.
handlers
.
abort
)
:
        
"
"
"
Merge
working
directory
with
rev
.
If
no
revision
is
specified
the
        
working
directory
'
s
parent
is
a
head
revision
and
the
current
        
branch
contains
exactly
one
other
head
the
other
head
is
        
merged
with
by
default
.
        
The
current
working
directory
is
updated
with
all
changes
made
in
the
        
requested
revision
since
the
last
common
predecessor
revision
.
        
Files
that
changed
between
either
parent
are
marked
as
changed
for
the
        
next
commit
and
a
commit
must
be
performed
before
any
further
updates
to
        
the
repository
are
allowed
.
The
next
commit
will
have
two
parents
.
        
force
-
force
a
merge
with
outstanding
changes
        
tool
-
can
be
used
to
specify
the
merge
tool
used
for
file
merges
.
It
        
overrides
the
HGMERGE
environment
variable
and
your
configuration
files
.
        
cb
-
controls
the
behaviour
when
Mercurial
prompts
what
to
do
        
with
regard
to
a
specific
file
e
.
g
.
when
one
parent
modified
        
a
file
and
the
other
removed
it
.
It
can
be
one
of
        
merge
.
handlers
or
a
function
that
gets
a
single
argument
        
which
are
the
contents
of
stdout
.
It
should
return
one
of
the
        
expected
choices
(
a
single
character
)
.
        
"
"
"
        
#
we
can
'
t
really
use
-
-
preview
since
merge
doesn
'
t
support
-
-
template
        
args
=
cmdbuilder
(
b
(
'
merge
'
)
r
=
rev
f
=
force
t
=
tool
)
        
prompt
=
None
        
if
cb
is
merge
.
handlers
.
abort
:
            
prompt
=
cb
        
elif
cb
is
merge
.
handlers
.
noninteractive
:
            
args
.
append
(
b
(
'
-
y
'
)
)
        
else
:
            
prompt
=
lambda
size
output
:
cb
(
output
)
+
b
(
'
\
n
'
)
        
self
.
rawcommand
(
args
prompt
=
prompt
)
    
def
move
(
self
source
dest
after
=
False
force
=
False
dryrun
=
False
             
include
=
None
exclude
=
None
)
:
        
"
"
"
Mark
dest
as
copies
of
source
;
mark
source
for
deletion
.
If
dest
        
is
a
directory
copies
are
put
in
that
directory
.
If
dest
is
a
        
file
then
source
must
be
a
string
.
        
Returns
True
on
success
False
if
errors
are
encountered
.
        
source
-
a
file
or
a
list
of
files
        
dest
-
a
destination
file
or
directory
        
after
-
record
a
rename
that
has
already
occurred
        
force
-
forcibly
copy
over
an
existing
managed
file
        
dryrun
-
do
not
perform
actions
just
print
output
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
source
list
)
:
            
source
=
[
source
]
        
source
.
append
(
dest
)
        
args
=
cmdbuilder
(
b
(
'
move
'
)
A
=
after
f
=
force
n
=
dryrun
                          
I
=
include
X
=
exclude
*
source
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
outgoing
(
self
revrange
=
None
path
=
None
force
=
False
newest
=
False
                 
bookmarks
=
False
branch
=
None
limit
=
None
nomerges
=
False
                 
subrepos
=
False
)
:
        
"
"
"
Return
changesets
not
found
in
the
specified
path
or
the
default
push
        
location
.
        
When
bookmarks
=
True
return
a
list
of
(
name
node
)
of
        
bookmarks
that
will
be
pushed
.
        
revrange
-
a
(
list
of
)
changeset
intended
to
be
included
in
        
the
destination
force
-
run
even
when
the
destination
is
        
unrelated
newest
-
show
newest
record
first
branch
-
a
        
specific
branch
you
would
like
to
push
limit
-
limit
number
of
        
changes
displayed
nomerges
-
do
not
show
merges
ssh
-
specify
        
ssh
command
to
use
remotecmd
-
specify
hg
command
to
run
on
        
the
remote
side
insecure
-
do
not
verify
server
certificate
        
(
ignoring
web
.
cacerts
config
)
subrepos
-
recurse
into
        
subrepositories
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
outgoing
'
)
                          
path
                          
template
=
templates
.
changeset
r
=
revrange
                          
f
=
force
n
=
newest
B
=
bookmarks
                          
b
=
branch
S
=
subrepos
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
!
=
1
:
                
raise
error
.
CommandError
(
args
ret
out
err
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
        
if
not
out
:
            
return
[
]
        
out
=
util
.
eatlines
(
out
2
)
        
if
bookmarks
:
            
bms
=
[
]
            
for
line
in
out
.
splitlines
(
)
:
                
bms
.
append
(
tuple
(
line
.
split
(
)
)
)
            
return
bms
        
else
:
            
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
            
return
self
.
_parserevs
(
out
)
    
def
parents
(
self
rev
=
None
file
=
None
)
:
        
"
"
"
Return
the
working
directory
'
s
parent
revisions
.
If
rev
is
given
        
the
parent
of
that
revision
will
be
printed
.
If
file
is
given
        
the
revision
in
which
the
file
was
last
changed
(
before
the
        
working
directory
revision
or
the
revision
specified
by
rev
)
        
is
returned
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
parents
'
)
file
template
=
templates
.
changeset
                          
r
=
rev
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
if
not
out
:
            
return
        
out
=
out
.
split
(
b
(
'
\
0
'
)
)
[
:
-
1
]
        
return
self
.
_parserevs
(
out
)
    
def
paths
(
self
name
=
None
)
:
        
"
"
"
        
Return
the
definition
of
given
symbolic
path
name
.
If
no
name
is
given
        
return
a
dictionary
of
pathname
:
url
of
all
available
names
.
        
Path
names
are
defined
in
the
[
paths
]
section
of
your
configuration
file
        
and
in
"
/
etc
/
mercurial
/
hgrc
"
.
If
run
inside
a
repository
"
.
hg
/
hgrc
"
is
        
used
too
.
        
"
"
"
        
if
not
name
:
            
out
=
self
.
rawcommand
(
[
b
(
'
paths
'
)
]
)
            
if
not
out
:
                
return
{
}
            
return
dict
(
[
s
.
split
(
b
(
'
=
'
)
)
                         
for
s
in
out
.
rstrip
(
)
.
split
(
b
(
'
\
n
'
)
)
]
)
        
else
:
            
args
=
cmdbuilder
(
b
(
'
paths
'
)
name
)
            
out
=
self
.
rawcommand
(
args
)
            
return
out
.
rstrip
(
)
    
def
pull
(
self
source
=
None
rev
=
None
update
=
False
force
=
False
             
bookmark
=
None
branch
=
None
ssh
=
None
remotecmd
=
None
             
insecure
=
False
tool
=
None
)
:
        
"
"
"
Pull
changes
from
a
remote
repository
.
        
This
finds
all
changes
from
the
repository
specified
by
source
        
and
adds
them
to
this
repository
.
If
source
is
omitted
the
        
'
default
'
path
will
be
used
.
By
default
this
does
not
update
        
the
copy
of
the
project
in
the
working
directory
.
        
Returns
True
on
success
False
if
update
was
given
and
there
were
        
unresolved
files
.
        
update
-
update
to
new
branch
head
if
changesets
were
pulled
        
force
-
run
even
when
remote
repository
is
unrelated
        
rev
-
a
(
list
of
)
remote
changeset
intended
to
be
added
        
bookmark
-
(
list
of
)
bookmark
to
pull
        
branch
-
a
(
list
of
)
specific
branch
you
would
like
to
pull
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
         
web
.
cacerts
config
)
        
tool
-
specify
merge
tool
for
rebase
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
pull
'
)
source
r
=
rev
u
=
update
f
=
force
                          
B
=
bookmark
b
=
branch
e
=
ssh
                          
remotecmd
=
remotecmd
insecure
=
insecure
                          
t
=
tool
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
push
(
self
dest
=
None
rev
=
None
force
=
False
bookmark
=
None
branch
=
None
             
newbranch
=
False
ssh
=
None
remotecmd
=
None
insecure
=
False
)
:
        
"
"
"
Push
changesets
from
this
repository
to
the
specified
destination
.
        
This
operation
is
symmetrical
to
pull
:
it
is
identical
to
a
pull
in
the
        
destination
repository
from
the
current
one
.
        
Returns
True
if
push
was
successful
False
if
nothing
to
push
.
        
rev
-
the
(
list
of
)
specified
revision
and
all
its
ancestors
        
will
be
pushed
to
the
remote
repository
.
        
force
-
override
the
default
behavior
and
push
all
changesets
on
all
        
branches
.
        
bookmark
-
(
list
of
)
bookmark
to
push
        
branch
-
a
(
list
of
)
specific
branch
you
would
like
to
push
        
newbranch
-
allows
push
to
create
a
new
named
branch
that
is
         
not
present
at
the
destination
.
This
allows
you
to
only
create
         
a
new
branch
without
forcing
other
changes
.
        
ssh
-
specify
ssh
command
to
use
        
remotecmd
-
specify
hg
command
to
run
on
the
remote
side
        
insecure
-
do
not
verify
server
certificate
(
ignoring
         
web
.
cacerts
config
)
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
push
'
)
dest
r
=
rev
f
=
force
B
=
bookmark
b
=
branch
                          
new_branch
=
newbranch
e
=
ssh
remotecmd
=
remotecmd
                          
insecure
=
insecure
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
remove
(
self
files
after
=
False
force
=
False
include
=
None
               
exclude
=
None
)
:
        
"
"
"
Schedule
the
indicated
files
for
removal
from
the
repository
.
This
        
only
removes
files
from
the
current
branch
not
from
the
        
entire
project
history
.
        
Returns
True
on
success
False
if
any
warnings
encountered
.
        
after
-
used
to
remove
only
files
that
have
already
been
deleted
        
force
-
remove
(
and
delete
)
file
even
if
added
or
modified
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
remove
'
)
A
=
after
f
=
force
I
=
include
X
=
exclude
                          
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
resolve
(
self
file
=
[
]
all
=
False
listfiles
=
False
mark
=
False
                
unmark
=
False
tool
=
None
include
=
None
exclude
=
None
)
:
        
"
"
"
        
Redo
merges
or
set
/
view
the
merge
status
of
given
files
.
        
Returns
True
on
success
False
if
any
files
fail
a
resolve
attempt
.
        
When
listfiles
is
True
returns
a
list
of
(
code
file
path
)
of
resolved
        
and
unresolved
files
.
Code
will
be
'
R
'
or
'
U
'
accordingly
.
        
all
-
select
all
unresolved
files
        
mark
-
mark
files
as
resolved
        
unmark
-
mark
files
as
unresolved
        
tool
-
specify
merge
tool
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
not
isinstance
(
file
list
)
:
            
file
=
[
file
]
        
args
=
cmdbuilder
(
b
(
'
resolve
'
)
a
=
all
l
=
listfiles
m
=
mark
u
=
unmark
                          
t
=
tool
I
=
include
X
=
exclude
*
file
)
        
out
=
self
.
rawcommand
(
args
)
        
if
listfiles
:
            
l
=
[
]
            
for
line
in
out
.
splitlines
(
)
:
                
l
.
append
(
tuple
(
line
.
split
(
b
(
'
'
)
1
)
)
)
            
return
l
    
def
revert
(
self
files
rev
=
None
all
=
False
date
=
None
nobackup
=
False
               
dryrun
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
With
no
revision
specified
revert
the
specified
files
or
        
directories
to
the
contents
they
had
in
the
parent
of
the
        
working
directory
.
This
restores
the
contents
of
files
to
an
        
unmodified
state
and
unschedules
adds
removes
copies
and
        
renames
.
If
the
working
directory
has
two
parents
you
must
        
explicitly
specify
a
revision
.
        
Specifying
rev
or
date
will
revert
the
given
files
or
        
directories
to
their
states
as
of
a
specific
revision
.
Because
        
revert
does
not
change
the
working
directory
parents
this
        
will
cause
these
files
to
appear
modified
.
This
can
be
helpful
        
to
"
back
out
"
some
or
all
of
an
earlier
change
.
        
Modified
files
are
saved
with
a
.
orig
suffix
before
reverting
.
        
To
disable
these
backups
use
nobackup
.
        
Returns
True
on
success
.
        
all
-
revert
all
changes
when
no
arguments
given
        
date
-
tipmost
revision
matching
date
        
rev
-
revert
to
the
specified
revision
        
nobackup
-
do
not
save
backup
copies
of
files
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
dryrun
-
do
not
perform
actions
just
print
output
        
"
"
"
        
if
not
isinstance
(
files
list
)
:
            
files
=
[
files
]
        
args
=
cmdbuilder
(
b
(
'
revert
'
)
r
=
rev
a
=
all
d
=
date
                          
no_backup
=
nobackup
n
=
dryrun
I
=
include
X
=
exclude
                          
hidden
=
self
.
hidden
*
files
)
        
eh
=
util
.
reterrorhandler
(
args
)
        
self
.
rawcommand
(
args
eh
=
eh
)
        
return
bool
(
eh
)
    
def
root
(
self
)
:
        
"
"
"
        
Return
the
root
directory
of
the
current
repository
.
        
"
"
"
        
return
self
.
rawcommand
(
[
b
(
'
root
'
)
]
)
.
rstrip
(
)
    
def
status
(
self
rev
=
None
change
=
None
all
=
False
modified
=
False
               
added
=
False
removed
=
False
deleted
=
False
clean
=
False
               
unknown
=
False
ignored
=
False
copies
=
False
               
subrepos
=
False
include
=
None
exclude
=
None
)
:
        
"
"
"
        
Return
status
of
files
in
the
repository
as
a
list
of
(
code
file
path
)
        
where
code
can
be
:
                
M
=
modified
                
A
=
added
                
R
=
removed
                
C
=
clean
                
!
=
missing
(
deleted
by
non
-
hg
command
but
still
tracked
)
                
?
=
untracked
                
I
=
ignored
                  
=
origin
of
the
previous
file
listed
as
A
(
added
)
        
rev
-
show
difference
from
(
list
of
)
revision
        
change
-
list
the
changed
files
of
a
revision
        
all
-
show
status
of
all
files
        
modified
-
show
only
modified
files
        
added
-
show
only
added
files
        
removed
-
show
only
removed
files
        
deleted
-
show
only
deleted
(
but
tracked
)
files
        
clean
-
show
only
files
without
changes
        
unknown
-
show
only
unknown
(
not
tracked
)
files
        
ignored
-
show
only
ignored
files
        
copies
-
show
source
of
copied
files
        
subrepos
-
recurse
into
subrepositories
        
include
-
include
names
matching
the
given
patterns
        
exclude
-
exclude
names
matching
the
given
patterns
        
"
"
"
        
if
rev
and
change
:
            
raise
ValueError
(
'
cannot
specify
both
rev
and
change
'
)
        
args
=
cmdbuilder
(
b
(
'
status
'
)
rev
=
rev
change
=
change
A
=
all
                          
m
=
modified
a
=
added
r
=
removed
d
=
deleted
c
=
clean
                          
u
=
unknown
i
=
ignored
C
=
copies
S
=
subrepos
I
=
include
                          
X
=
exclude
hidden
=
self
.
hidden
)
        
args
.
append
(
b
(
'
-
0
'
)
)
        
out
=
self
.
rawcommand
(
args
)
        
l
=
[
]
        
for
entry
in
out
.
split
(
b
(
'
\
0
'
)
)
:
            
if
entry
:
                
if
entry
[
0
:
1
]
=
=
b
(
'
'
)
:
                    
l
.
append
(
(
b
(
'
'
)
entry
[
2
:
]
)
)
                
else
:
                    
l
.
append
(
tuple
(
entry
.
split
(
b
(
'
'
)
1
)
)
)
        
return
l
    
def
tag
(
self
names
rev
=
None
message
=
None
force
=
False
local
=
False
            
remove
=
False
date
=
None
user
=
None
)
:
        
"
"
"
Add
one
or
more
tags
specified
by
names
for
the
current
or
given
        
revision
.
        
Changing
an
existing
tag
is
normally
disallowed
;
use
force
to
override
.
        
Tag
commits
are
usually
made
at
the
head
of
a
branch
.
If
the
        
parent
of
the
working
directory
is
not
a
branch
head
a
        
CommandError
will
be
raised
.
force
can
be
specified
to
force
        
the
tag
commit
to
be
based
on
a
non
-
head
changeset
.
        
local
-
make
the
tag
local
        
rev
-
revision
to
tag
        
remove
-
remove
a
tag
        
message
-
set
commit
message
        
date
-
record
the
specified
date
as
commit
date
        
user
-
record
the
specified
user
as
committer
        
"
"
"
        
if
not
isinstance
(
names
list
)
:
            
names
=
[
names
]
        
args
=
cmdbuilder
(
b
(
'
tag
'
)
r
=
rev
m
=
message
f
=
force
l
=
local
                          
remove
=
remove
d
=
date
u
=
user
hidden
=
self
.
hidden
                          
*
names
)
        
self
.
rawcommand
(
args
)
    
def
tags
(
self
)
:
        
"
"
"
        
Return
a
list
of
repository
tags
as
:
(
name
rev
node
islocal
)
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
tags
'
)
v
=
True
)
        
out
=
self
.
rawcommand
(
args
)
        
t
=
[
]
        
for
line
in
out
.
splitlines
(
)
:
            
taglocal
=
line
.
endswith
(
b
(
'
local
'
)
)
            
if
taglocal
:
                
line
=
line
[
:
-
6
]
            
name
rev
=
line
.
rsplit
(
b
(
'
'
)
1
)
            
rev
node
=
rev
.
split
(
b
(
'
:
'
)
)
            
t
.
append
(
(
name
.
rstrip
(
)
int
(
rev
)
node
taglocal
)
)
        
return
t
    
def
phase
(
self
revs
=
(
)
secret
=
False
draft
=
False
public
=
False
              
force
=
False
)
:
        
'
'
'
Set
or
show
the
current
phase
name
.
        
revs
-
target
revision
(
s
)
        
public
-
set
changeset
phase
to
public
        
draft
-
set
changeset
phase
to
draft
        
secret
-
set
changeset
phase
to
secret
        
force
-
allow
to
move
boundary
backward
        
output
format
:
[
(
id
phase
)
.
.
.
]
for
each
changeset
        
The
arguments
match
the
mercurial
API
.
        
'
'
'
        
if
not
isinstance
(
revs
(
list
tuple
)
)
:
            
revs
=
[
revs
]
        
args
=
util
.
cmdbuilder
(
b
(
'
phase
'
)
secret
=
secret
draft
=
draft
                               
public
=
public
force
=
force
                               
hidden
=
self
.
hidden
*
revs
)
        
out
=
self
.
rawcommand
(
args
)
        
if
draft
or
public
or
secret
:
            
return
        
else
:
            
output
=
[
i
.
split
(
b
(
'
:
'
)
)
for
i
in
out
.
strip
(
)
.
split
(
b
(
'
\
n
'
)
)
]
            
return
[
(
int
(
num
)
phase
)
for
(
num
phase
)
in
output
]
    
def
summary
(
self
remote
=
False
)
:
        
"
"
"
        
Return
a
dictionary
with
a
brief
summary
of
the
working
directory
state
        
including
parents
branch
commit
status
and
available
updates
.
            
'
parent
'
:
a
list
of
(
rev
node
tags
message
)
            
'
branch
'
:
the
current
branch
            
'
commit
'
:
True
if
the
working
directory
is
clean
False
otherwise
            
'
update
'
:
number
of
available
updates
            
[
'
remote
'
:
(
in
in
bookmarks
out
out
bookmarks
)
]
            
[
'
mq
'
:
(
applied
unapplied
)
mq
patches
]
            
unparsed
entries
will
be
of
them
form
key
:
value
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
summary
'
)
remote
=
remote
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
.
splitlines
(
)
        
d
=
{
}
        
while
out
:
            
line
=
out
.
pop
(
0
)
            
name
value
=
line
.
split
(
b
(
'
:
'
)
1
)
            
if
name
=
=
b
(
'
parent
'
)
:
                
parent
tags
=
value
.
split
(
b
(
'
'
)
1
)
                
rev
node
=
parent
.
split
(
b
(
'
:
'
)
)
                
if
tags
:
                    
tags
=
tags
.
replace
(
b
(
'
(
empty
repository
)
'
)
b
(
'
'
)
)
                
else
:
                    
tags
=
None
                
value
=
d
.
get
(
name
[
]
)
                
if
rev
=
=
b
(
'
-
1
'
)
:
                    
value
.
append
(
(
int
(
rev
)
node
tags
None
)
)
                
else
:
                    
message
=
out
.
pop
(
0
)
[
1
:
]
                    
value
.
append
(
(
int
(
rev
)
node
tags
message
)
)
            
elif
name
=
=
b
(
'
branch
'
)
:
                
pass
            
elif
name
=
=
b
(
'
commit
'
)
:
                
value
=
value
=
=
b
(
'
(
clean
)
'
)
            
elif
name
=
=
b
(
'
update
'
)
:
                
if
value
=
=
b
(
'
(
current
)
'
)
:
                    
value
=
0
                
else
:
                    
value
=
int
(
value
.
split
(
b
(
'
'
)
1
)
[
0
]
)
            
elif
remote
and
name
=
=
b
(
'
remote
'
)
:
                
if
value
=
=
b
(
'
(
synced
)
'
)
:
                    
value
=
0
0
0
0
                
else
:
                    
inc
=
incb
=
out_
=
outb
=
0
                    
for
v
in
value
.
split
(
b
(
'
'
)
)
:
                        
count
v
=
v
.
split
(
b
(
'
'
)
1
)
                        
if
v
=
=
b
(
'
outgoing
'
)
:
                            
out_
=
int
(
count
)
                        
elif
v
.
endswith
(
b
(
'
incoming
'
)
)
:
                            
inc
=
int
(
count
)
                        
elif
v
=
=
b
(
'
incoming
bookmarks
'
)
:
                            
incb
=
int
(
count
)
                        
elif
v
=
=
b
(
'
outgoing
bookmarks
'
)
:
                            
outb
=
int
(
count
)
                    
value
=
inc
incb
out_
outb
            
elif
name
=
=
b
(
'
mq
'
)
:
                
applied
=
unapplied
=
0
                
for
v
in
value
.
split
(
b
(
'
'
)
)
:
                    
count
v
=
v
.
split
(
b
(
'
'
)
1
)
                    
if
v
=
=
b
(
'
applied
'
)
:
                        
applied
=
int
(
count
)
                    
elif
v
=
=
b
(
'
unapplied
'
)
:
                        
unapplied
=
int
(
count
)
                
value
=
applied
unapplied
            
d
[
name
]
=
value
        
return
d
    
def
tip
(
self
)
:
        
"
"
"
        
Return
the
tip
revision
(
usually
just
called
the
tip
)
which
is
the
        
changeset
most
recently
added
to
the
repository
(
and
therefore
the
most
        
recently
changed
head
)
.
        
"
"
"
        
args
=
cmdbuilder
(
b
(
'
tip
'
)
template
=
templates
.
changeset
                          
hidden
=
self
.
hidden
)
        
out
=
self
.
rawcommand
(
args
)
        
out
=
out
.
split
(
b
(
'
\
0
'
)
)
        
return
self
.
_parserevs
(
out
)
[
0
]
    
def
update
(
self
rev
=
None
clean
=
False
check
=
False
date
=
None
)
:
        
"
"
"
        
Update
the
repository
'
s
working
directory
to
changeset
specified
by
rev
.
        
If
rev
isn
'
t
specified
update
to
the
tip
of
the
current
named
branch
.
        
Return
the
number
of
files
(
updated
merged
removed
unresolved
)
        
clean
-
discard
uncommitted
changes
(
no
backup
)
        
check
-
update
across
branches
if
no
uncommitted
changes
        
date
-
tipmost
revision
matching
date
        
"
"
"
        
if
clean
and
check
:
            
raise
ValueError
(
'
clean
and
check
cannot
both
be
True
'
)
        
args
=
cmdbuilder
(
b
(
'
update
'
)
r
=
rev
C
=
clean
c
=
check
d
=
date
                          
hidden
=
self
.
hidden
)
        
def
eh
(
ret
out
err
)
:
            
if
ret
=
=
1
:
                
return
out
            
raise
error
.
CommandError
(
args
ret
out
err
)
        
out
=
self
.
rawcommand
(
args
eh
=
eh
)
        
m
=
re
.
search
(
b
(
r
'
^
(
\
d
+
)
.
+
(
\
d
+
)
.
+
(
\
d
+
)
.
+
(
\
d
+
)
'
)
out
                      
re
.
MULTILINE
)
        
return
tuple
(
map
(
int
list
(
m
.
groups
(
)
)
)
)
    
property
    
def
version
(
self
)
:
        
"
"
"
Return
hg
version
that
runs
the
command
server
as
a
4
fielded
        
tuple
:
major
minor
micro
and
local
build
info
.
e
.
g
.
(
1
9
        
1
'
+
4
-
3095db9f5c2c
'
)
        
"
"
"
        
if
self
.
_version
is
None
:
            
v
=
self
.
rawcommand
(
cmdbuilder
(
b
(
'
version
'
)
q
=
True
)
)
            
v
=
list
(
re
.
match
(
b
(
r
'
.
*
?
(
\
d
+
)
\
.
(
\
d
+
)
\
.
?
(
\
d
+
)
?
(
\
+
[
0
-
9a
-
f
-
]
+
)
?
'
)
                              
v
)
.
groups
(
)
)
            
for
i
in
range
(
3
)
:
                
try
:
                    
v
[
i
]
=
int
(
v
[
i
]
)
                
except
TypeError
:
                    
v
[
i
]
=
0
            
self
.
_version
=
tuple
(
v
)
        
return
self
.
_version
    
def
__getitem__
(
self
changeid
)
:
        
try
:
            
return
context
.
changectx
(
self
changeid
)
        
except
ValueError
as
e
:
            
raise
KeyError
(
*
e
.
args
)
    
def
__contains__
(
self
changeid
)
:
        
"
"
"
        
check
if
changeid
which
can
be
either
a
local
revision
number
or
a
        
changeset
id
matches
a
changeset
in
the
client
.
        
"
"
"
        
try
:
            
context
.
changectx
(
self
changeid
)
            
return
True
        
except
ValueError
:
            
return
False
