repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
serge-sans-paille/pythran | pythran/analyses/aliases.py | Aliases.visit_ListComp | def visit_ListComp(self, node):
'''
A comprehension is not abstracted in any way
>>> from pythran import passmanager
>>> pm = passmanager.PassManager('demo')
>>> module = ast.parse('def foo(a, b): return [a for i in b]')
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.ListComp)
[a for i in b] => ['<unbound-value>']
'''
for generator in node.generators:
self.visit_comprehension(generator)
self.visit(node.elt)
return self.add(node) | python | def visit_ListComp(self, node):
'''
A comprehension is not abstracted in any way
>>> from pythran import passmanager
>>> pm = passmanager.PassManager('demo')
>>> module = ast.parse('def foo(a, b): return [a for i in b]')
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.ListComp)
[a for i in b] => ['<unbound-value>']
'''
for generator in node.generators:
self.visit_comprehension(generator)
self.visit(node.elt)
return self.add(node) | [
"def",
"visit_ListComp",
"(",
"self",
",",
"node",
")",
":",
"for",
"generator",
"in",
"node",
".",
"generators",
":",
"self",
".",
"visit_comprehension",
"(",
"generator",
")",
"self",
".",
"visit",
"(",
"node",
".",
"elt",
")",
"return",
"self",
".",
... | A comprehension is not abstracted in any way
>>> from pythran import passmanager
>>> pm = passmanager.PassManager('demo')
>>> module = ast.parse('def foo(a, b): return [a for i in b]')
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.ListComp)
[a for i in b] => ['<unbound-value>'] | [
"A",
"comprehension",
"is",
"not",
"abstracted",
"in",
"any",
"way"
] | 7e1b5af2dddfabc50bd2a977f0178be269b349b5 | https://github.com/serge-sans-paille/pythran/blob/7e1b5af2dddfabc50bd2a977f0178be269b349b5/pythran/analyses/aliases.py#L493-L507 | train |
serge-sans-paille/pythran | pythran/analyses/aliases.py | Aliases.visit_FunctionDef | def visit_FunctionDef(self, node):
'''
Initialise aliasing default value before visiting.
Add aliasing values for :
- Pythonic
- globals declarations
- current function arguments
'''
self.aliases = IntrinsicAliases.copy()
self.aliases.update((f.name, {f})
for f in self.global_declarations.values())
self.aliases.update((arg.id, {arg})
for arg in node.args.args)
self.generic_visit(node)
if Aliases.RetId in self.aliases:
# parametrize the expression
def parametrize(exp):
# constant(?) or global -> no change
if isinstance(exp, (ast.Index, Intrinsic, ast.FunctionDef)):
return lambda _: {exp}
elif isinstance(exp, ContainerOf):
pcontainee = parametrize(exp.containee)
index = exp.index
return lambda args: {
ContainerOf(pc, index)
for pc in pcontainee(args)
}
elif isinstance(exp, ast.Name):
try:
w = node.args.args.index(exp)
def return_alias(args):
if w < len(args):
return {args[w]}
else:
return {node.args.defaults[w - len(args)]}
return return_alias
except ValueError:
return lambda _: self.get_unbound_value_set()
elif isinstance(exp, ast.Subscript):
values = parametrize(exp.value)
slices = parametrize(exp.slice)
return lambda args: {
ast.Subscript(value, slice, ast.Load())
for value in values(args)
for slice in slices(args)}
else:
return lambda _: self.get_unbound_value_set()
# this is a little tricky: for each returned alias,
# parametrize builds a function that, given a list of args,
# returns the alias
# then as we may have multiple returned alias, we compute the union
# of these returned aliases
return_aliases = [parametrize(ret_alias)
for ret_alias
in self.aliases[Aliases.RetId]]
def merge_return_aliases(args):
merged_return_aliases = set()
for return_alias in return_aliases:
merged_return_aliases.update(return_alias(args))
return merged_return_aliases
node.return_alias = merge_return_aliases | python | def visit_FunctionDef(self, node):
'''
Initialise aliasing default value before visiting.
Add aliasing values for :
- Pythonic
- globals declarations
- current function arguments
'''
self.aliases = IntrinsicAliases.copy()
self.aliases.update((f.name, {f})
for f in self.global_declarations.values())
self.aliases.update((arg.id, {arg})
for arg in node.args.args)
self.generic_visit(node)
if Aliases.RetId in self.aliases:
# parametrize the expression
def parametrize(exp):
# constant(?) or global -> no change
if isinstance(exp, (ast.Index, Intrinsic, ast.FunctionDef)):
return lambda _: {exp}
elif isinstance(exp, ContainerOf):
pcontainee = parametrize(exp.containee)
index = exp.index
return lambda args: {
ContainerOf(pc, index)
for pc in pcontainee(args)
}
elif isinstance(exp, ast.Name):
try:
w = node.args.args.index(exp)
def return_alias(args):
if w < len(args):
return {args[w]}
else:
return {node.args.defaults[w - len(args)]}
return return_alias
except ValueError:
return lambda _: self.get_unbound_value_set()
elif isinstance(exp, ast.Subscript):
values = parametrize(exp.value)
slices = parametrize(exp.slice)
return lambda args: {
ast.Subscript(value, slice, ast.Load())
for value in values(args)
for slice in slices(args)}
else:
return lambda _: self.get_unbound_value_set()
# this is a little tricky: for each returned alias,
# parametrize builds a function that, given a list of args,
# returns the alias
# then as we may have multiple returned alias, we compute the union
# of these returned aliases
return_aliases = [parametrize(ret_alias)
for ret_alias
in self.aliases[Aliases.RetId]]
def merge_return_aliases(args):
merged_return_aliases = set()
for return_alias in return_aliases:
merged_return_aliases.update(return_alias(args))
return merged_return_aliases
node.return_alias = merge_return_aliases | [
"def",
"visit_FunctionDef",
"(",
"self",
",",
"node",
")",
":",
"self",
".",
"aliases",
"=",
"IntrinsicAliases",
".",
"copy",
"(",
")",
"self",
".",
"aliases",
".",
"update",
"(",
"(",
"f",
".",
"name",
",",
"{",
"f",
"}",
")",
"for",
"f",
"in",
... | Initialise aliasing default value before visiting.
Add aliasing values for :
- Pythonic
- globals declarations
- current function arguments | [
"Initialise",
"aliasing",
"default",
"value",
"before",
"visiting",
"."
] | 7e1b5af2dddfabc50bd2a977f0178be269b349b5 | https://github.com/serge-sans-paille/pythran/blob/7e1b5af2dddfabc50bd2a977f0178be269b349b5/pythran/analyses/aliases.py#L532-L600 | train |
serge-sans-paille/pythran | pythran/analyses/aliases.py | Aliases.visit_For | def visit_For(self, node):
'''
For loop creates aliasing between the target
and the content of the iterator
>>> from pythran import passmanager
>>> pm = passmanager.PassManager('demo')
>>> module = ast.parse("""
... def foo(a):
... for i in a:
... {i}""")
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.Set)
{i} => ['|i|']
Not very useful, unless we know something about the iterated container
>>> module = ast.parse("""
... def foo(a, b):
... for i in [a, b]:
... {i}""")
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.Set)
{i} => ['|a|', '|b|']
'''
iter_aliases = self.visit(node.iter)
if all(isinstance(x, ContainerOf) for x in iter_aliases):
target_aliases = set()
for iter_alias in iter_aliases:
target_aliases.add(iter_alias.containee)
else:
target_aliases = {node.target}
self.add(node.target, target_aliases)
self.aliases[node.target.id] = self.result[node.target]
self.generic_visit(node)
self.generic_visit(node) | python | def visit_For(self, node):
'''
For loop creates aliasing between the target
and the content of the iterator
>>> from pythran import passmanager
>>> pm = passmanager.PassManager('demo')
>>> module = ast.parse("""
... def foo(a):
... for i in a:
... {i}""")
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.Set)
{i} => ['|i|']
Not very useful, unless we know something about the iterated container
>>> module = ast.parse("""
... def foo(a, b):
... for i in [a, b]:
... {i}""")
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.Set)
{i} => ['|a|', '|b|']
'''
iter_aliases = self.visit(node.iter)
if all(isinstance(x, ContainerOf) for x in iter_aliases):
target_aliases = set()
for iter_alias in iter_aliases:
target_aliases.add(iter_alias.containee)
else:
target_aliases = {node.target}
self.add(node.target, target_aliases)
self.aliases[node.target.id] = self.result[node.target]
self.generic_visit(node)
self.generic_visit(node) | [
"def",
"visit_For",
"(",
"self",
",",
"node",
")",
":",
"iter_aliases",
"=",
"self",
".",
"visit",
"(",
"node",
".",
"iter",
")",
"if",
"all",
"(",
"isinstance",
"(",
"x",
",",
"ContainerOf",
")",
"for",
"x",
"in",
"iter_aliases",
")",
":",
"target_a... | For loop creates aliasing between the target
and the content of the iterator
>>> from pythran import passmanager
>>> pm = passmanager.PassManager('demo')
>>> module = ast.parse("""
... def foo(a):
... for i in a:
... {i}""")
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.Set)
{i} => ['|i|']
Not very useful, unless we know something about the iterated container
>>> module = ast.parse("""
... def foo(a, b):
... for i in [a, b]:
... {i}""")
>>> result = pm.gather(Aliases, module)
>>> Aliases.dump(result, filter=ast.Set)
{i} => ['|a|', '|b|'] | [
"For",
"loop",
"creates",
"aliasing",
"between",
"the",
"target",
"and",
"the",
"content",
"of",
"the",
"iterator"
] | 7e1b5af2dddfabc50bd2a977f0178be269b349b5 | https://github.com/serge-sans-paille/pythran/blob/7e1b5af2dddfabc50bd2a977f0178be269b349b5/pythran/analyses/aliases.py#L628-L666 | train |
serge-sans-paille/pythran | pythran/analyses/argument_read_once.py | ArgumentReadOnce.prepare | def prepare(self, node):
"""
Initialise arguments effects as this analysis in inter-procedural.
Initialisation done for Pythonic functions and default values set for
user defined functions.
"""
super(ArgumentReadOnce, self).prepare(node)
# global functions init
for n in self.global_declarations.values():
fe = ArgumentReadOnce.FunctionEffects(n)
self.node_to_functioneffect[n] = fe
self.result.add(fe)
# Pythonic functions init
def save_effect(module):
""" Recursively save read once effect for Pythonic functions. """
for intr in module.values():
if isinstance(intr, dict): # Submodule case
save_effect(intr)
else:
fe = ArgumentReadOnce.FunctionEffects(intr)
self.node_to_functioneffect[intr] = fe
self.result.add(fe)
if isinstance(intr, intrinsic.Class): # Class case
save_effect(intr.fields)
for module in MODULES.values():
save_effect(module) | python | def prepare(self, node):
"""
Initialise arguments effects as this analysis in inter-procedural.
Initialisation done for Pythonic functions and default values set for
user defined functions.
"""
super(ArgumentReadOnce, self).prepare(node)
# global functions init
for n in self.global_declarations.values():
fe = ArgumentReadOnce.FunctionEffects(n)
self.node_to_functioneffect[n] = fe
self.result.add(fe)
# Pythonic functions init
def save_effect(module):
""" Recursively save read once effect for Pythonic functions. """
for intr in module.values():
if isinstance(intr, dict): # Submodule case
save_effect(intr)
else:
fe = ArgumentReadOnce.FunctionEffects(intr)
self.node_to_functioneffect[intr] = fe
self.result.add(fe)
if isinstance(intr, intrinsic.Class): # Class case
save_effect(intr.fields)
for module in MODULES.values():
save_effect(module) | [
"def",
"prepare",
"(",
"self",
",",
"node",
")",
":",
"super",
"(",
"ArgumentReadOnce",
",",
"self",
")",
".",
"prepare",
"(",
"node",
")",
"for",
"n",
"in",
"self",
".",
"global_declarations",
".",
"values",
"(",
")",
":",
"fe",
"=",
"ArgumentReadOnce... | Initialise arguments effects as this analysis in inter-procedural.
Initialisation done for Pythonic functions and default values set for
user defined functions. | [
"Initialise",
"arguments",
"effects",
"as",
"this",
"analysis",
"in",
"inter",
"-",
"procedural",
"."
] | 7e1b5af2dddfabc50bd2a977f0178be269b349b5 | https://github.com/serge-sans-paille/pythran/blob/7e1b5af2dddfabc50bd2a977f0178be269b349b5/pythran/analyses/argument_read_once.py#L60-L88 | train |
astropy/regions | regions/io/ds9/write.py | ds9_objects_to_string | def ds9_objects_to_string(regions, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to DS9 region string.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
coordsys : `str`, optional
This overrides the coordinate system frame for all regions.
Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is 'deg'(degrees)
Returns
-------
region_string : `str`
DS9 region string
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, ds9_objects_to_string
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> print(ds9_objects_to_string([reg_sky]))
# Region file format: DS9 astropy/regions
fk5
circle(1.000007,2.000002,5.000000)
"""
shapelist = to_shape_list(regions, coordsys)
return shapelist.to_ds9(coordsys, fmt, radunit) | python | def ds9_objects_to_string(regions, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to DS9 region string.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
coordsys : `str`, optional
This overrides the coordinate system frame for all regions.
Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is 'deg'(degrees)
Returns
-------
region_string : `str`
DS9 region string
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, ds9_objects_to_string
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> print(ds9_objects_to_string([reg_sky]))
# Region file format: DS9 astropy/regions
fk5
circle(1.000007,2.000002,5.000000)
"""
shapelist = to_shape_list(regions, coordsys)
return shapelist.to_ds9(coordsys, fmt, radunit) | [
"def",
"ds9_objects_to_string",
"(",
"regions",
",",
"coordsys",
"=",
"'fk5'",
",",
"fmt",
"=",
"'.6f'",
",",
"radunit",
"=",
"'deg'",
")",
":",
"shapelist",
"=",
"to_shape_list",
"(",
"regions",
",",
"coordsys",
")",
"return",
"shapelist",
".",
"to_ds9",
... | Converts a `list` of `~regions.Region` to DS9 region string.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
coordsys : `str`, optional
This overrides the coordinate system frame for all regions.
Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is 'deg'(degrees)
Returns
-------
region_string : `str`
DS9 region string
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, ds9_objects_to_string
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> print(ds9_objects_to_string([reg_sky]))
# Region file format: DS9 astropy/regions
fk5
circle(1.000007,2.000002,5.000000) | [
"Converts",
"a",
"list",
"of",
"~regions",
".",
"Region",
"to",
"DS9",
"region",
"string",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/write.py#L12-L46 | train |
astropy/regions | regions/io/ds9/write.py | write_ds9 | def write_ds9(regions, filename, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to DS9 string and write to file.
Parameters
----------
regions : `list`
List of `regions.Region` objects
filename : `str`
Filename in which the string is to be written.
coordsys : `str`, optional #TODO
Coordinate system that overrides the coordinate frames of all regions.
Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, write_ds9
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> write_ds9([reg_sky], 'test_write.reg')
>>> with open('test_write.reg') as f:
... print(f.read())
# Region file format: DS9 astropy/regions
fk5
circle(1.000007,2.000002,5.000000)
"""
output = ds9_objects_to_string(regions, coordsys, fmt, radunit)
with open(filename, 'w') as fh:
fh.write(output) | python | def write_ds9(regions, filename, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to DS9 string and write to file.
Parameters
----------
regions : `list`
List of `regions.Region` objects
filename : `str`
Filename in which the string is to be written.
coordsys : `str`, optional #TODO
Coordinate system that overrides the coordinate frames of all regions.
Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, write_ds9
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> write_ds9([reg_sky], 'test_write.reg')
>>> with open('test_write.reg') as f:
... print(f.read())
# Region file format: DS9 astropy/regions
fk5
circle(1.000007,2.000002,5.000000)
"""
output = ds9_objects_to_string(regions, coordsys, fmt, radunit)
with open(filename, 'w') as fh:
fh.write(output) | [
"def",
"write_ds9",
"(",
"regions",
",",
"filename",
",",
"coordsys",
"=",
"'fk5'",
",",
"fmt",
"=",
"'.6f'",
",",
"radunit",
"=",
"'deg'",
")",
":",
"output",
"=",
"ds9_objects_to_string",
"(",
"regions",
",",
"coordsys",
",",
"fmt",
",",
"radunit",
")"... | Converts a `list` of `~regions.Region` to DS9 string and write to file.
Parameters
----------
regions : `list`
List of `regions.Region` objects
filename : `str`
Filename in which the string is to be written.
coordsys : `str`, optional #TODO
Coordinate system that overrides the coordinate frames of all regions.
Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, write_ds9
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> write_ds9([reg_sky], 'test_write.reg')
>>> with open('test_write.reg') as f:
... print(f.read())
# Region file format: DS9 astropy/regions
fk5
circle(1.000007,2.000002,5.000000) | [
"Converts",
"a",
"list",
"of",
"~regions",
".",
"Region",
"to",
"DS9",
"string",
"and",
"write",
"to",
"file",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/write.py#L49-L83 | train |
astropy/regions | regions/io/crtf/write.py | crtf_objects_to_string | def crtf_objects_to_string(regions, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to CRTF region string.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
coordsys : `str`, optional
Astropy Coordinate system that overrides the coordinate system frame for
all regions. Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Returns
-------
region_string : `str`
CRTF region string
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, crtf_objects_to_string
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> print(crtf_objects_to_string([reg_sky]))
#CRTF
global coord=fk5
+circle[[1.000007deg, 2.000002deg], 5.000000deg]
"""
shapelist = to_shape_list(regions, coordsys)
return shapelist.to_crtf(coordsys, fmt, radunit) | python | def crtf_objects_to_string(regions, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to CRTF region string.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
coordsys : `str`, optional
Astropy Coordinate system that overrides the coordinate system frame for
all regions. Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Returns
-------
region_string : `str`
CRTF region string
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, crtf_objects_to_string
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> print(crtf_objects_to_string([reg_sky]))
#CRTF
global coord=fk5
+circle[[1.000007deg, 2.000002deg], 5.000000deg]
"""
shapelist = to_shape_list(regions, coordsys)
return shapelist.to_crtf(coordsys, fmt, radunit) | [
"def",
"crtf_objects_to_string",
"(",
"regions",
",",
"coordsys",
"=",
"'fk5'",
",",
"fmt",
"=",
"'.6f'",
",",
"radunit",
"=",
"'deg'",
")",
":",
"shapelist",
"=",
"to_shape_list",
"(",
"regions",
",",
"coordsys",
")",
"return",
"shapelist",
".",
"to_crtf",
... | Converts a `list` of `~regions.Region` to CRTF region string.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
coordsys : `str`, optional
Astropy Coordinate system that overrides the coordinate system frame for
all regions. Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Returns
-------
region_string : `str`
CRTF region string
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, crtf_objects_to_string
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> print(crtf_objects_to_string([reg_sky]))
#CRTF
global coord=fk5
+circle[[1.000007deg, 2.000002deg], 5.000000deg] | [
"Converts",
"a",
"list",
"of",
"~regions",
".",
"Region",
"to",
"CRTF",
"region",
"string",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/write.py#L12-L48 | train |
astropy/regions | regions/io/crtf/write.py | write_crtf | def write_crtf(regions, filename, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to CRTF string and write to file.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
filename : `str`
Filename in which the string is to be written. Default is 'new.crtf'
coordsys : `str`, optional
Astropy Coordinate system that overrides the coordinate frames of all
regions. Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, write_crtf
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> write_crtf([reg_sky], 'test_write.crtf')
>>> with open('test_write.crtf') as f:
... print(f.read())
#CRTF
global coord=fk5
+circle[[1.000007deg, 2.000002deg], 5.000000deg]
"""
output = crtf_objects_to_string(regions, coordsys, fmt, radunit)
with open(filename, 'w') as fh:
fh.write(output) | python | def write_crtf(regions, filename, coordsys='fk5', fmt='.6f', radunit='deg'):
"""
Converts a `list` of `~regions.Region` to CRTF string and write to file.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
filename : `str`
Filename in which the string is to be written. Default is 'new.crtf'
coordsys : `str`, optional
Astropy Coordinate system that overrides the coordinate frames of all
regions. Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, write_crtf
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> write_crtf([reg_sky], 'test_write.crtf')
>>> with open('test_write.crtf') as f:
... print(f.read())
#CRTF
global coord=fk5
+circle[[1.000007deg, 2.000002deg], 5.000000deg]
"""
output = crtf_objects_to_string(regions, coordsys, fmt, radunit)
with open(filename, 'w') as fh:
fh.write(output) | [
"def",
"write_crtf",
"(",
"regions",
",",
"filename",
",",
"coordsys",
"=",
"'fk5'",
",",
"fmt",
"=",
"'.6f'",
",",
"radunit",
"=",
"'deg'",
")",
":",
"output",
"=",
"crtf_objects_to_string",
"(",
"regions",
",",
"coordsys",
",",
"fmt",
",",
"radunit",
"... | Converts a `list` of `~regions.Region` to CRTF string and write to file.
Parameters
----------
regions : `list`
List of `~regions.Region` objects
filename : `str`
Filename in which the string is to be written. Default is 'new.crtf'
coordsys : `str`, optional
Astropy Coordinate system that overrides the coordinate frames of all
regions. Default is 'fk5'.
fmt : `str`, optional
A python string format defining the output precision. Default is .6f,
which is accurate to 0.0036 arcseconds.
radunit : `str`, optional
This denotes the unit of the radius. Default is deg (degrees)
Examples
--------
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord
>>> from regions import CircleSkyRegion, write_crtf
>>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg)
>>> write_crtf([reg_sky], 'test_write.crtf')
>>> with open('test_write.crtf') as f:
... print(f.read())
#CRTF
global coord=fk5
+circle[[1.000007deg, 2.000002deg], 5.000000deg] | [
"Converts",
"a",
"list",
"of",
"~regions",
".",
"Region",
"to",
"CRTF",
"string",
"and",
"write",
"to",
"file",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/write.py#L51-L86 | train |
astropy/regions | regions/shapes/rectangle.py | RectanglePixelRegion.corners | def corners(self):
"""
Return the x, y coordinate pairs that define the corners
"""
corners = [(-self.width/2, -self.height/2),
( self.width/2, -self.height/2),
( self.width/2, self.height/2),
(-self.width/2, self.height/2),
]
rotmat = [[np.cos(self.angle), np.sin(self.angle)],
[-np.sin(self.angle), np.cos(self.angle)]]
return np.dot(corners, rotmat) + np.array([self.center.x,
self.center.y]) | python | def corners(self):
"""
Return the x, y coordinate pairs that define the corners
"""
corners = [(-self.width/2, -self.height/2),
( self.width/2, -self.height/2),
( self.width/2, self.height/2),
(-self.width/2, self.height/2),
]
rotmat = [[np.cos(self.angle), np.sin(self.angle)],
[-np.sin(self.angle), np.cos(self.angle)]]
return np.dot(corners, rotmat) + np.array([self.center.x,
self.center.y]) | [
"def",
"corners",
"(",
"self",
")",
":",
"corners",
"=",
"[",
"(",
"-",
"self",
".",
"width",
"/",
"2",
",",
"-",
"self",
".",
"height",
"/",
"2",
")",
",",
"(",
"self",
".",
"width",
"/",
"2",
",",
"-",
"self",
".",
"height",
"/",
"2",
")"... | Return the x, y coordinate pairs that define the corners | [
"Return",
"the",
"x",
"y",
"coordinate",
"pairs",
"that",
"define",
"the",
"corners"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/shapes/rectangle.py#L202-L216 | train |
astropy/regions | regions/shapes/rectangle.py | RectanglePixelRegion.to_polygon | def to_polygon(self):
"""
Return a 4-cornered polygon equivalent to this rectangle
"""
x,y = self.corners.T
vertices = PixCoord(x=x, y=y)
return PolygonPixelRegion(vertices=vertices, meta=self.meta,
visual=self.visual) | python | def to_polygon(self):
"""
Return a 4-cornered polygon equivalent to this rectangle
"""
x,y = self.corners.T
vertices = PixCoord(x=x, y=y)
return PolygonPixelRegion(vertices=vertices, meta=self.meta,
visual=self.visual) | [
"def",
"to_polygon",
"(",
"self",
")",
":",
"x",
",",
"y",
"=",
"self",
".",
"corners",
".",
"T",
"vertices",
"=",
"PixCoord",
"(",
"x",
"=",
"x",
",",
"y",
"=",
"y",
")",
"return",
"PolygonPixelRegion",
"(",
"vertices",
"=",
"vertices",
",",
"meta... | Return a 4-cornered polygon equivalent to this rectangle | [
"Return",
"a",
"4",
"-",
"cornered",
"polygon",
"equivalent",
"to",
"this",
"rectangle"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/shapes/rectangle.py#L218-L225 | train |
astropy/regions | regions/shapes/rectangle.py | RectanglePixelRegion._lower_left_xy | def _lower_left_xy(self):
"""
Compute lower left `xy` position.
This is used for the conversion to matplotlib in ``as_artist``
Taken from http://photutils.readthedocs.io/en/latest/_modules/photutils/aperture/rectangle.html#RectangularAperture.plot
"""
hw = self.width / 2.
hh = self.height / 2.
sint = np.sin(self.angle)
cost = np.cos(self.angle)
dx = (hh * sint) - (hw * cost)
dy = -(hh * cost) - (hw * sint)
x = self.center.x + dx
y = self.center.y + dy
return x, y | python | def _lower_left_xy(self):
"""
Compute lower left `xy` position.
This is used for the conversion to matplotlib in ``as_artist``
Taken from http://photutils.readthedocs.io/en/latest/_modules/photutils/aperture/rectangle.html#RectangularAperture.plot
"""
hw = self.width / 2.
hh = self.height / 2.
sint = np.sin(self.angle)
cost = np.cos(self.angle)
dx = (hh * sint) - (hw * cost)
dy = -(hh * cost) - (hw * sint)
x = self.center.x + dx
y = self.center.y + dy
return x, y | [
"def",
"_lower_left_xy",
"(",
"self",
")",
":",
"hw",
"=",
"self",
".",
"width",
"/",
"2.",
"hh",
"=",
"self",
".",
"height",
"/",
"2.",
"sint",
"=",
"np",
".",
"sin",
"(",
"self",
".",
"angle",
")",
"cost",
"=",
"np",
".",
"cos",
"(",
"self",
... | Compute lower left `xy` position.
This is used for the conversion to matplotlib in ``as_artist``
Taken from http://photutils.readthedocs.io/en/latest/_modules/photutils/aperture/rectangle.html#RectangularAperture.plot | [
"Compute",
"lower",
"left",
"xy",
"position",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/shapes/rectangle.py#L228-L244 | train |
astropy/regions | regions/core/compound.py | CompoundPixelRegion._make_annulus_path | def _make_annulus_path(patch_inner, patch_outer):
"""
Defines a matplotlib annulus path from two patches.
This preserves the cubic Bezier curves (CURVE4) of the aperture
paths.
# This is borrowed from photutils aperture.
"""
import matplotlib.path as mpath
path_inner = patch_inner.get_path()
transform_inner = patch_inner.get_transform()
path_inner = transform_inner.transform_path(path_inner)
path_outer = patch_outer.get_path()
transform_outer = patch_outer.get_transform()
path_outer = transform_outer.transform_path(path_outer)
verts_inner = path_inner.vertices[:-1][::-1]
verts_inner = np.concatenate((verts_inner, [verts_inner[-1]]))
verts = np.vstack((path_outer.vertices, verts_inner))
codes = np.hstack((path_outer.codes, path_inner.codes))
return mpath.Path(verts, codes) | python | def _make_annulus_path(patch_inner, patch_outer):
"""
Defines a matplotlib annulus path from two patches.
This preserves the cubic Bezier curves (CURVE4) of the aperture
paths.
# This is borrowed from photutils aperture.
"""
import matplotlib.path as mpath
path_inner = patch_inner.get_path()
transform_inner = patch_inner.get_transform()
path_inner = transform_inner.transform_path(path_inner)
path_outer = patch_outer.get_path()
transform_outer = patch_outer.get_transform()
path_outer = transform_outer.transform_path(path_outer)
verts_inner = path_inner.vertices[:-1][::-1]
verts_inner = np.concatenate((verts_inner, [verts_inner[-1]]))
verts = np.vstack((path_outer.vertices, verts_inner))
codes = np.hstack((path_outer.codes, path_inner.codes))
return mpath.Path(verts, codes) | [
"def",
"_make_annulus_path",
"(",
"patch_inner",
",",
"patch_outer",
")",
":",
"import",
"matplotlib",
".",
"path",
"as",
"mpath",
"path_inner",
"=",
"patch_inner",
".",
"get_path",
"(",
")",
"transform_inner",
"=",
"patch_inner",
".",
"get_transform",
"(",
")",... | Defines a matplotlib annulus path from two patches.
This preserves the cubic Bezier curves (CURVE4) of the aperture
paths.
# This is borrowed from photutils aperture. | [
"Defines",
"a",
"matplotlib",
"annulus",
"path",
"from",
"two",
"patches",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/core/compound.py#L104-L130 | train |
astropy/regions | regions/io/fits/read.py | read_fits_region | def read_fits_region(filename, errors='strict'):
"""
Reads a FITS region file and scans for any fits regions table and
converts them into `Region` objects.
Parameters
----------
filename : str
The file path
errors : ``warn``, ``ignore``, ``strict``
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `FITSRegionParserError`.
``warn`` will raise a `FITSRegionParserWarning`, and ``ignore`` will do nothing
(i.e., be silent).
Returns
-------
regions : list
Python list of `regions.Region` objects.
Examples
--------
>>> from astropy.utils.data import get_pkg_data_filename
>>> from regions import read_fits_region
>>> file_read = get_pkg_data_filename('data/region.fits',
... package='regions.io.fits.tests')
>>> regions = read_fits_region(file_read)
"""
regions = []
hdul = fits.open(filename)
for hdu in hdul:
if hdu.name == 'REGION':
table = Table.read(hdu)
wcs = WCS(hdu.header, keysel=['image', 'binary', 'pixel'])
regions_list = FITSRegionParser(table, errors).shapes.to_regions()
for reg in regions_list:
regions.append(reg.to_sky(wcs))
return regions | python | def read_fits_region(filename, errors='strict'):
"""
Reads a FITS region file and scans for any fits regions table and
converts them into `Region` objects.
Parameters
----------
filename : str
The file path
errors : ``warn``, ``ignore``, ``strict``
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `FITSRegionParserError`.
``warn`` will raise a `FITSRegionParserWarning`, and ``ignore`` will do nothing
(i.e., be silent).
Returns
-------
regions : list
Python list of `regions.Region` objects.
Examples
--------
>>> from astropy.utils.data import get_pkg_data_filename
>>> from regions import read_fits_region
>>> file_read = get_pkg_data_filename('data/region.fits',
... package='regions.io.fits.tests')
>>> regions = read_fits_region(file_read)
"""
regions = []
hdul = fits.open(filename)
for hdu in hdul:
if hdu.name == 'REGION':
table = Table.read(hdu)
wcs = WCS(hdu.header, keysel=['image', 'binary', 'pixel'])
regions_list = FITSRegionParser(table, errors).shapes.to_regions()
for reg in regions_list:
regions.append(reg.to_sky(wcs))
return regions | [
"def",
"read_fits_region",
"(",
"filename",
",",
"errors",
"=",
"'strict'",
")",
":",
"regions",
"=",
"[",
"]",
"hdul",
"=",
"fits",
".",
"open",
"(",
"filename",
")",
"for",
"hdu",
"in",
"hdul",
":",
"if",
"hdu",
".",
"name",
"==",
"'REGION'",
":",
... | Reads a FITS region file and scans for any fits regions table and
converts them into `Region` objects.
Parameters
----------
filename : str
The file path
errors : ``warn``, ``ignore``, ``strict``
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `FITSRegionParserError`.
``warn`` will raise a `FITSRegionParserWarning`, and ``ignore`` will do nothing
(i.e., be silent).
Returns
-------
regions : list
Python list of `regions.Region` objects.
Examples
--------
>>> from astropy.utils.data import get_pkg_data_filename
>>> from regions import read_fits_region
>>> file_read = get_pkg_data_filename('data/region.fits',
... package='regions.io.fits.tests')
>>> regions = read_fits_region(file_read) | [
"Reads",
"a",
"FITS",
"region",
"file",
"and",
"scans",
"for",
"any",
"fits",
"regions",
"table",
"and",
"converts",
"them",
"into",
"Region",
"objects",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/fits/read.py#L228-L270 | train |
astropy/regions | regions/io/core.py | to_shape_list | def to_shape_list(region_list, coordinate_system='fk5'):
"""
Converts a list of regions into a `regions.ShapeList` object.
Parameters
----------
region_list: python list
Lists of `regions.Region` objects
format_type: str ('DS9' or 'CRTF')
The format type of the Shape object. Default is 'DS9'.
coordinate_system: str
The astropy coordinate system frame in which all the coordinates present
in the `region_list` will be converted. Default is 'fk5'.
Returns
-------
shape_list: `regions.ShapeList` object
list of `regions.Shape` objects.
"""
shape_list = ShapeList()
for region in region_list:
coord = []
if isinstance(region, SkyRegion):
reg_type = region.__class__.__name__[:-9].lower()
else:
reg_type = region.__class__.__name__[:-11].lower()
for val in regions_attributes[reg_type]:
coord.append(getattr(region, val))
if reg_type == 'polygon':
coord = [x for x in region.vertices]
if coordinate_system:
coordsys = coordinate_system
else:
if isinstance(region, SkyRegion):
coordsys = coord[0].name
else:
coordsys = 'image'
frame = coordinates.frame_transform_graph.lookup_name(coordsys)
new_coord = []
for val in coord:
if isinstance(val, Angle) or isinstance(val, u.Quantity) or isinstance(val, numbers.Number):
new_coord.append(val)
elif isinstance(val, PixCoord):
new_coord.append(u.Quantity(val.x, u.dimensionless_unscaled))
new_coord.append(u.Quantity(val.y, u.dimensionless_unscaled))
else:
new_coord.append(Angle(val.transform_to(frame).spherical.lon))
new_coord.append(Angle(val.transform_to(frame).spherical.lat))
meta = dict(region.meta)
meta.update(region.visual)
if reg_type == 'text':
meta['text'] = meta.get('text', meta.pop('label', ''))
include = region.meta.pop('include', True)
shape_list.append(Shape(coordsys, reg_type, new_coord, meta, False,
include))
return shape_list | python | def to_shape_list(region_list, coordinate_system='fk5'):
"""
Converts a list of regions into a `regions.ShapeList` object.
Parameters
----------
region_list: python list
Lists of `regions.Region` objects
format_type: str ('DS9' or 'CRTF')
The format type of the Shape object. Default is 'DS9'.
coordinate_system: str
The astropy coordinate system frame in which all the coordinates present
in the `region_list` will be converted. Default is 'fk5'.
Returns
-------
shape_list: `regions.ShapeList` object
list of `regions.Shape` objects.
"""
shape_list = ShapeList()
for region in region_list:
coord = []
if isinstance(region, SkyRegion):
reg_type = region.__class__.__name__[:-9].lower()
else:
reg_type = region.__class__.__name__[:-11].lower()
for val in regions_attributes[reg_type]:
coord.append(getattr(region, val))
if reg_type == 'polygon':
coord = [x for x in region.vertices]
if coordinate_system:
coordsys = coordinate_system
else:
if isinstance(region, SkyRegion):
coordsys = coord[0].name
else:
coordsys = 'image'
frame = coordinates.frame_transform_graph.lookup_name(coordsys)
new_coord = []
for val in coord:
if isinstance(val, Angle) or isinstance(val, u.Quantity) or isinstance(val, numbers.Number):
new_coord.append(val)
elif isinstance(val, PixCoord):
new_coord.append(u.Quantity(val.x, u.dimensionless_unscaled))
new_coord.append(u.Quantity(val.y, u.dimensionless_unscaled))
else:
new_coord.append(Angle(val.transform_to(frame).spherical.lon))
new_coord.append(Angle(val.transform_to(frame).spherical.lat))
meta = dict(region.meta)
meta.update(region.visual)
if reg_type == 'text':
meta['text'] = meta.get('text', meta.pop('label', ''))
include = region.meta.pop('include', True)
shape_list.append(Shape(coordsys, reg_type, new_coord, meta, False,
include))
return shape_list | [
"def",
"to_shape_list",
"(",
"region_list",
",",
"coordinate_system",
"=",
"'fk5'",
")",
":",
"shape_list",
"=",
"ShapeList",
"(",
")",
"for",
"region",
"in",
"region_list",
":",
"coord",
"=",
"[",
"]",
"if",
"isinstance",
"(",
"region",
",",
"SkyRegion",
... | Converts a list of regions into a `regions.ShapeList` object.
Parameters
----------
region_list: python list
Lists of `regions.Region` objects
format_type: str ('DS9' or 'CRTF')
The format type of the Shape object. Default is 'DS9'.
coordinate_system: str
The astropy coordinate system frame in which all the coordinates present
in the `region_list` will be converted. Default is 'fk5'.
Returns
-------
shape_list: `regions.ShapeList` object
list of `regions.Shape` objects. | [
"Converts",
"a",
"list",
"of",
"regions",
"into",
"a",
"regions",
".",
"ShapeList",
"object",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L670-L738 | train |
astropy/regions | regions/io/core.py | to_ds9_meta | def to_ds9_meta(shape_meta):
"""
Makes the meta data DS9 compatible by filtering and mapping the valid keys
Parameters
----------
shape_meta: dict
meta attribute of a `regions.Shape` object
Returns
-------
meta : dict
DS9 compatible meta dictionary
"""
# meta keys allowed in DS9.
valid_keys = ['symbol', 'include', 'tag', 'line', 'comment',
'name', 'select', 'highlite', 'fixed', 'label', 'text',
'edit', 'move', 'rotate', 'delete', 'source', 'background']
# visual keys allowed in DS9
valid_keys += ['color', 'dash', 'linewidth', 'font', 'dashlist',
'fill', 'textangle', 'symsize']
# mapped to actual names in DS9
key_mappings = {'symbol': 'point', 'linewidth': 'width', 'label': 'text'}
meta = _to_io_meta(shape_meta, valid_keys, key_mappings)
if 'font' in meta:
meta['font'] += " {0} {1} {2}".format(shape_meta.get('fontsize', 12),
shape_meta.get('fontstyle', 'normal'),
shape_meta.get('fontweight', 'roman'))
return meta | python | def to_ds9_meta(shape_meta):
"""
Makes the meta data DS9 compatible by filtering and mapping the valid keys
Parameters
----------
shape_meta: dict
meta attribute of a `regions.Shape` object
Returns
-------
meta : dict
DS9 compatible meta dictionary
"""
# meta keys allowed in DS9.
valid_keys = ['symbol', 'include', 'tag', 'line', 'comment',
'name', 'select', 'highlite', 'fixed', 'label', 'text',
'edit', 'move', 'rotate', 'delete', 'source', 'background']
# visual keys allowed in DS9
valid_keys += ['color', 'dash', 'linewidth', 'font', 'dashlist',
'fill', 'textangle', 'symsize']
# mapped to actual names in DS9
key_mappings = {'symbol': 'point', 'linewidth': 'width', 'label': 'text'}
meta = _to_io_meta(shape_meta, valid_keys, key_mappings)
if 'font' in meta:
meta['font'] += " {0} {1} {2}".format(shape_meta.get('fontsize', 12),
shape_meta.get('fontstyle', 'normal'),
shape_meta.get('fontweight', 'roman'))
return meta | [
"def",
"to_ds9_meta",
"(",
"shape_meta",
")",
":",
"valid_keys",
"=",
"[",
"'symbol'",
",",
"'include'",
",",
"'tag'",
",",
"'line'",
",",
"'comment'",
",",
"'name'",
",",
"'select'",
",",
"'highlite'",
",",
"'fixed'",
",",
"'label'",
",",
"'text'",
",",
... | Makes the meta data DS9 compatible by filtering and mapping the valid keys
Parameters
----------
shape_meta: dict
meta attribute of a `regions.Shape` object
Returns
-------
meta : dict
DS9 compatible meta dictionary | [
"Makes",
"the",
"meta",
"data",
"DS9",
"compatible",
"by",
"filtering",
"and",
"mapping",
"the",
"valid",
"keys"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L741-L775 | train |
astropy/regions | regions/io/core.py | _to_io_meta | def _to_io_meta(shape_meta, valid_keys, key_mappings):
"""
This is used to make meta data compatible with a specific io
by filtering and mapping to it's valid keys
Parameters
----------
shape_meta: dict
meta attribute of a `regions.Region` object
valid_keys : python list
Contains all the valid keys of a particular file format.
key_mappings : python dict
Maps to the actual name of the key in the format.
Returns
-------
meta : dict
io compatible meta dictionary according to valid_keys and key_mappings
"""
meta = dict()
for key in shape_meta:
if key in valid_keys:
meta[key_mappings.get(key, key)] = shape_meta[key]
return meta | python | def _to_io_meta(shape_meta, valid_keys, key_mappings):
"""
This is used to make meta data compatible with a specific io
by filtering and mapping to it's valid keys
Parameters
----------
shape_meta: dict
meta attribute of a `regions.Region` object
valid_keys : python list
Contains all the valid keys of a particular file format.
key_mappings : python dict
Maps to the actual name of the key in the format.
Returns
-------
meta : dict
io compatible meta dictionary according to valid_keys and key_mappings
"""
meta = dict()
for key in shape_meta:
if key in valid_keys:
meta[key_mappings.get(key, key)] = shape_meta[key]
return meta | [
"def",
"_to_io_meta",
"(",
"shape_meta",
",",
"valid_keys",
",",
"key_mappings",
")",
":",
"meta",
"=",
"dict",
"(",
")",
"for",
"key",
"in",
"shape_meta",
":",
"if",
"key",
"in",
"valid_keys",
":",
"meta",
"[",
"key_mappings",
".",
"get",
"(",
"key",
... | This is used to make meta data compatible with a specific io
by filtering and mapping to it's valid keys
Parameters
----------
shape_meta: dict
meta attribute of a `regions.Region` object
valid_keys : python list
Contains all the valid keys of a particular file format.
key_mappings : python dict
Maps to the actual name of the key in the format.
Returns
-------
meta : dict
io compatible meta dictionary according to valid_keys and key_mappings | [
"This",
"is",
"used",
"to",
"make",
"meta",
"data",
"compatible",
"with",
"a",
"specific",
"io",
"by",
"filtering",
"and",
"mapping",
"to",
"it",
"s",
"valid",
"keys"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L809-L835 | train |
astropy/regions | regions/io/core.py | Shape.convert_coords | def convert_coords(self):
"""
Process list of coordinates
This mainly searches for tuple of coordinates in the coordinate list and
creates a SkyCoord or PixCoord object from them if appropriate for a
given region type. This involves again some coordinate transformation,
so this step could be moved to the parsing process
"""
if self.coordsys in ['image', 'physical']:
coords = self._convert_pix_coords()
else:
coords = self._convert_sky_coords()
if self.region_type == 'line':
coords = [coords[0][0], coords[0][1]]
if self.region_type == 'text':
coords.append(self.meta['text'])
return coords | python | def convert_coords(self):
"""
Process list of coordinates
This mainly searches for tuple of coordinates in the coordinate list and
creates a SkyCoord or PixCoord object from them if appropriate for a
given region type. This involves again some coordinate transformation,
so this step could be moved to the parsing process
"""
if self.coordsys in ['image', 'physical']:
coords = self._convert_pix_coords()
else:
coords = self._convert_sky_coords()
if self.region_type == 'line':
coords = [coords[0][0], coords[0][1]]
if self.region_type == 'text':
coords.append(self.meta['text'])
return coords | [
"def",
"convert_coords",
"(",
"self",
")",
":",
"if",
"self",
".",
"coordsys",
"in",
"[",
"'image'",
",",
"'physical'",
"]",
":",
"coords",
"=",
"self",
".",
"_convert_pix_coords",
"(",
")",
"else",
":",
"coords",
"=",
"self",
".",
"_convert_sky_coords",
... | Process list of coordinates
This mainly searches for tuple of coordinates in the coordinate list and
creates a SkyCoord or PixCoord object from them if appropriate for a
given region type. This involves again some coordinate transformation,
so this step could be moved to the parsing process | [
"Process",
"list",
"of",
"coordinates"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L527-L547 | train |
astropy/regions | regions/io/core.py | Shape._convert_sky_coords | def _convert_sky_coords(self):
"""
Convert to sky coordinates
"""
parsed_angles = [(x, y)
for x, y in zip(self.coord[:-1:2], self.coord[1::2])
if (isinstance(x, coordinates.Angle) and isinstance(y, coordinates.Angle))
]
frame = coordinates.frame_transform_graph.lookup_name(self.coordsys)
lon, lat = zip(*parsed_angles)
if hasattr(lon, '__len__') and hasattr(lat, '__len__') and len(lon) == 1 and len(lat) == 1:
# force entries to be scalar if they are length-1
lon, lat = u.Quantity(lon[0]), u.Quantity(lat[0])
else:
# otherwise, they are vector quantities
lon, lat = u.Quantity(lon), u.Quantity(lat)
sphcoords = coordinates.UnitSphericalRepresentation(lon, lat)
coords = [SkyCoord(frame(sphcoords))]
if self.region_type != 'polygon':
coords += self.coord[len(coords * 2):]
return coords | python | def _convert_sky_coords(self):
"""
Convert to sky coordinates
"""
parsed_angles = [(x, y)
for x, y in zip(self.coord[:-1:2], self.coord[1::2])
if (isinstance(x, coordinates.Angle) and isinstance(y, coordinates.Angle))
]
frame = coordinates.frame_transform_graph.lookup_name(self.coordsys)
lon, lat = zip(*parsed_angles)
if hasattr(lon, '__len__') and hasattr(lat, '__len__') and len(lon) == 1 and len(lat) == 1:
# force entries to be scalar if they are length-1
lon, lat = u.Quantity(lon[0]), u.Quantity(lat[0])
else:
# otherwise, they are vector quantities
lon, lat = u.Quantity(lon), u.Quantity(lat)
sphcoords = coordinates.UnitSphericalRepresentation(lon, lat)
coords = [SkyCoord(frame(sphcoords))]
if self.region_type != 'polygon':
coords += self.coord[len(coords * 2):]
return coords | [
"def",
"_convert_sky_coords",
"(",
"self",
")",
":",
"parsed_angles",
"=",
"[",
"(",
"x",
",",
"y",
")",
"for",
"x",
",",
"y",
"in",
"zip",
"(",
"self",
".",
"coord",
"[",
":",
"-",
"1",
":",
"2",
"]",
",",
"self",
".",
"coord",
"[",
"1",
":"... | Convert to sky coordinates | [
"Convert",
"to",
"sky",
"coordinates"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L549-L572 | train |
astropy/regions | regions/io/core.py | Shape._convert_pix_coords | def _convert_pix_coords(self):
"""
Convert to pixel coordinates, `regions.PixCoord`
"""
if self.region_type in ['polygon', 'line']:
# have to special-case polygon in the phys coord case
# b/c can't typecheck when iterating as in sky coord case
coords = [PixCoord(self.coord[0::2], self.coord[1::2])]
else:
temp = [_.value for _ in self.coord]
coord = PixCoord(temp[0], temp[1])
coords = [coord] + temp[2:]
# The angle remains as a quantity object.
# Modulus check makes sure that it works for ellipse/rectangle annulus
if self.region_type in ['ellipse', 'rectangle'] and len(coords) % 2 == 0:
coords[-1] = self.coord[-1]
return coords | python | def _convert_pix_coords(self):
"""
Convert to pixel coordinates, `regions.PixCoord`
"""
if self.region_type in ['polygon', 'line']:
# have to special-case polygon in the phys coord case
# b/c can't typecheck when iterating as in sky coord case
coords = [PixCoord(self.coord[0::2], self.coord[1::2])]
else:
temp = [_.value for _ in self.coord]
coord = PixCoord(temp[0], temp[1])
coords = [coord] + temp[2:]
# The angle remains as a quantity object.
# Modulus check makes sure that it works for ellipse/rectangle annulus
if self.region_type in ['ellipse', 'rectangle'] and len(coords) % 2 == 0:
coords[-1] = self.coord[-1]
return coords | [
"def",
"_convert_pix_coords",
"(",
"self",
")",
":",
"if",
"self",
".",
"region_type",
"in",
"[",
"'polygon'",
",",
"'line'",
"]",
":",
"coords",
"=",
"[",
"PixCoord",
"(",
"self",
".",
"coord",
"[",
"0",
":",
":",
"2",
"]",
",",
"self",
".",
"coor... | Convert to pixel coordinates, `regions.PixCoord` | [
"Convert",
"to",
"pixel",
"coordinates",
"regions",
".",
"PixCoord"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L574-L592 | train |
astropy/regions | regions/io/core.py | Shape.to_region | def to_region(self):
"""
Converts to region, ``regions.Region`` object
"""
coords = self.convert_coords()
log.debug(coords)
viz_keywords = ['color', 'dash', 'dashlist', 'width', 'font', 'symsize',
'symbol', 'symsize', 'fontsize', 'fontstyle', 'usetex',
'labelpos', 'labeloff', 'linewidth', 'linestyle',
'point', 'textangle', 'fontweight']
if isinstance(coords[0], SkyCoord):
reg = self.shape_to_sky_region[self.region_type](*coords)
elif isinstance(coords[0], PixCoord):
reg = self.shape_to_pixel_region[self.region_type](*coords)
else:
self._raise_error("No central coordinate")
reg.visual = RegionVisual()
reg.meta = RegionMeta()
# both 'text' and 'label' should be set to the same value, where we
# default to the 'text' value since that is the one used by ds9 regions
label = self.meta.get('text',
self.meta.get('label', ""))
if label != '':
reg.meta['label'] = label
for key in self.meta:
if key in viz_keywords:
reg.visual[key] = self.meta[key]
else:
reg.meta[key] = self.meta[key]
reg.meta['include'] = self.include
return reg | python | def to_region(self):
"""
Converts to region, ``regions.Region`` object
"""
coords = self.convert_coords()
log.debug(coords)
viz_keywords = ['color', 'dash', 'dashlist', 'width', 'font', 'symsize',
'symbol', 'symsize', 'fontsize', 'fontstyle', 'usetex',
'labelpos', 'labeloff', 'linewidth', 'linestyle',
'point', 'textangle', 'fontweight']
if isinstance(coords[0], SkyCoord):
reg = self.shape_to_sky_region[self.region_type](*coords)
elif isinstance(coords[0], PixCoord):
reg = self.shape_to_pixel_region[self.region_type](*coords)
else:
self._raise_error("No central coordinate")
reg.visual = RegionVisual()
reg.meta = RegionMeta()
# both 'text' and 'label' should be set to the same value, where we
# default to the 'text' value since that is the one used by ds9 regions
label = self.meta.get('text',
self.meta.get('label', ""))
if label != '':
reg.meta['label'] = label
for key in self.meta:
if key in viz_keywords:
reg.visual[key] = self.meta[key]
else:
reg.meta[key] = self.meta[key]
reg.meta['include'] = self.include
return reg | [
"def",
"to_region",
"(",
"self",
")",
":",
"coords",
"=",
"self",
".",
"convert_coords",
"(",
")",
"log",
".",
"debug",
"(",
"coords",
")",
"viz_keywords",
"=",
"[",
"'color'",
",",
"'dash'",
",",
"'dashlist'",
",",
"'width'",
",",
"'font'",
",",
"'sym... | Converts to region, ``regions.Region`` object | [
"Converts",
"to",
"region",
"regions",
".",
"Region",
"object"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L594-L628 | train |
astropy/regions | regions/io/core.py | Shape.check_crtf | def check_crtf(self):
"""
Checks for CRTF compatibility.
"""
if self.region_type not in regions_attributes:
raise ValueError("'{0}' is not a valid region type in this package"
"supported by CRTF".format(self.region_type))
if self.coordsys not in valid_coordsys['CRTF']:
raise ValueError("'{0}' is not a valid coordinate reference frame in "
"astropy supported by CRTF".format(self.coordsys)) | python | def check_crtf(self):
"""
Checks for CRTF compatibility.
"""
if self.region_type not in regions_attributes:
raise ValueError("'{0}' is not a valid region type in this package"
"supported by CRTF".format(self.region_type))
if self.coordsys not in valid_coordsys['CRTF']:
raise ValueError("'{0}' is not a valid coordinate reference frame in "
"astropy supported by CRTF".format(self.coordsys)) | [
"def",
"check_crtf",
"(",
"self",
")",
":",
"if",
"self",
".",
"region_type",
"not",
"in",
"regions_attributes",
":",
"raise",
"ValueError",
"(",
"\"'{0}' is not a valid region type in this package\"",
"\"supported by CRTF\"",
".",
"format",
"(",
"self",
".",
"region_... | Checks for CRTF compatibility. | [
"Checks",
"for",
"CRTF",
"compatibility",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L633-L643 | train |
astropy/regions | regions/io/core.py | Shape.check_ds9 | def check_ds9(self):
"""
Checks for DS9 compatibility.
"""
if self.region_type not in regions_attributes:
raise ValueError("'{0}' is not a valid region type in this package"
"supported by DS9".format(self.region_type))
if self.coordsys not in valid_coordsys['DS9']:
raise ValueError("'{0}' is not a valid coordinate reference frame "
"in astropy supported by DS9".format(self.coordsys)) | python | def check_ds9(self):
"""
Checks for DS9 compatibility.
"""
if self.region_type not in regions_attributes:
raise ValueError("'{0}' is not a valid region type in this package"
"supported by DS9".format(self.region_type))
if self.coordsys not in valid_coordsys['DS9']:
raise ValueError("'{0}' is not a valid coordinate reference frame "
"in astropy supported by DS9".format(self.coordsys)) | [
"def",
"check_ds9",
"(",
"self",
")",
":",
"if",
"self",
".",
"region_type",
"not",
"in",
"regions_attributes",
":",
"raise",
"ValueError",
"(",
"\"'{0}' is not a valid region type in this package\"",
"\"supported by DS9\"",
".",
"format",
"(",
"self",
".",
"region_ty... | Checks for DS9 compatibility. | [
"Checks",
"for",
"DS9",
"compatibility",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L645-L655 | train |
astropy/regions | regions/io/core.py | Shape._validate | def _validate(self):
"""
Checks whether all the attributes of this object is valid.
"""
if self.region_type not in regions_attributes:
raise ValueError("'{0}' is not a valid region type in this package"
.format(self.region_type))
if self.coordsys not in valid_coordsys['DS9'] + valid_coordsys['CRTF']:
raise ValueError("'{0}' is not a valid coordinate reference frame "
"in astropy".format(self.coordsys)) | python | def _validate(self):
"""
Checks whether all the attributes of this object is valid.
"""
if self.region_type not in regions_attributes:
raise ValueError("'{0}' is not a valid region type in this package"
.format(self.region_type))
if self.coordsys not in valid_coordsys['DS9'] + valid_coordsys['CRTF']:
raise ValueError("'{0}' is not a valid coordinate reference frame "
"in astropy".format(self.coordsys)) | [
"def",
"_validate",
"(",
"self",
")",
":",
"if",
"self",
".",
"region_type",
"not",
"in",
"regions_attributes",
":",
"raise",
"ValueError",
"(",
"\"'{0}' is not a valid region type in this package\"",
".",
"format",
"(",
"self",
".",
"region_type",
")",
")",
"if",... | Checks whether all the attributes of this object is valid. | [
"Checks",
"whether",
"all",
"the",
"attributes",
"of",
"this",
"object",
"is",
"valid",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/core.py#L657-L667 | train |
astropy/regions | regions/io/crtf/read.py | read_crtf | def read_crtf(filename, errors='strict'):
"""
Reads a CRTF region file and returns a list of region objects.
Parameters
----------
filename : `str`
The file path
errors : ``warn``, ``ignore``, ``strict``, optional
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `~regions.CRTFRegionParserError`.
``warn`` will raise a `~regions.CRTFRegionParserWarning`, and ``ignore`` will do nothing
(i.e., be silent).
Returns
-------
regions : `list`
Python `list` of `~regions.Region` objects.
Examples
--------
>>> from regions import read_crtf
>>> from astropy.utils.data import get_pkg_data_filename
>>> file = get_pkg_data_filename('data/CRTFgeneral.crtf', package='regions.io.crtf.tests')
>>> regs = read_crtf(file, errors='warn')
>>> print(regs[0])
Region: CircleSkyRegion
center: <SkyCoord (FK4: equinox=B1950.000, obstime=B1950.000): (ra, dec) in deg
(273.1, -23.18333333)>
radius: 2.3 arcsec
>>> print(regs[0].meta)
{'frame': 'BARY', 'corr': ['I', 'Q'], 'include': True, 'type': 'ann'}
>>> print(regs[0].visual)
{'color': 'blue'}
"""
with open(filename) as fh:
if regex_begin.search(fh.readline()):
region_string = fh.read()
parser = CRTFParser(region_string, errors)
return parser.shapes.to_regions()
else:
raise CRTFRegionParserError('Every CRTF Region must start with "#CRTF" ') | python | def read_crtf(filename, errors='strict'):
"""
Reads a CRTF region file and returns a list of region objects.
Parameters
----------
filename : `str`
The file path
errors : ``warn``, ``ignore``, ``strict``, optional
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `~regions.CRTFRegionParserError`.
``warn`` will raise a `~regions.CRTFRegionParserWarning`, and ``ignore`` will do nothing
(i.e., be silent).
Returns
-------
regions : `list`
Python `list` of `~regions.Region` objects.
Examples
--------
>>> from regions import read_crtf
>>> from astropy.utils.data import get_pkg_data_filename
>>> file = get_pkg_data_filename('data/CRTFgeneral.crtf', package='regions.io.crtf.tests')
>>> regs = read_crtf(file, errors='warn')
>>> print(regs[0])
Region: CircleSkyRegion
center: <SkyCoord (FK4: equinox=B1950.000, obstime=B1950.000): (ra, dec) in deg
(273.1, -23.18333333)>
radius: 2.3 arcsec
>>> print(regs[0].meta)
{'frame': 'BARY', 'corr': ['I', 'Q'], 'include': True, 'type': 'ann'}
>>> print(regs[0].visual)
{'color': 'blue'}
"""
with open(filename) as fh:
if regex_begin.search(fh.readline()):
region_string = fh.read()
parser = CRTFParser(region_string, errors)
return parser.shapes.to_regions()
else:
raise CRTFRegionParserError('Every CRTF Region must start with "#CRTF" ') | [
"def",
"read_crtf",
"(",
"filename",
",",
"errors",
"=",
"'strict'",
")",
":",
"with",
"open",
"(",
"filename",
")",
"as",
"fh",
":",
"if",
"regex_begin",
".",
"search",
"(",
"fh",
".",
"readline",
"(",
")",
")",
":",
"region_string",
"=",
"fh",
".",... | Reads a CRTF region file and returns a list of region objects.
Parameters
----------
filename : `str`
The file path
errors : ``warn``, ``ignore``, ``strict``, optional
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `~regions.CRTFRegionParserError`.
``warn`` will raise a `~regions.CRTFRegionParserWarning`, and ``ignore`` will do nothing
(i.e., be silent).
Returns
-------
regions : `list`
Python `list` of `~regions.Region` objects.
Examples
--------
>>> from regions import read_crtf
>>> from astropy.utils.data import get_pkg_data_filename
>>> file = get_pkg_data_filename('data/CRTFgeneral.crtf', package='regions.io.crtf.tests')
>>> regs = read_crtf(file, errors='warn')
>>> print(regs[0])
Region: CircleSkyRegion
center: <SkyCoord (FK4: equinox=B1950.000, obstime=B1950.000): (ra, dec) in deg
(273.1, -23.18333333)>
radius: 2.3 arcsec
>>> print(regs[0].meta)
{'frame': 'BARY', 'corr': ['I', 'Q'], 'include': True, 'type': 'ann'}
>>> print(regs[0].visual)
{'color': 'blue'} | [
"Reads",
"a",
"CRTF",
"region",
"file",
"and",
"returns",
"a",
"list",
"of",
"region",
"objects",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/read.py#L43-L85 | train |
astropy/regions | regions/io/crtf/read.py | CRTFParser.parse_line | def parse_line(self, line):
"""
Parses a single line.
"""
# Skip blanks
if line == '':
return
# Skip comments
if regex_comment.search(line):
return
# Special case / header: parse global parameters into metadata
global_parameters = regex_global.search(line)
if global_parameters:
self.parse_global_meta(global_parameters.group('parameters'))
return
# Tries to check the validity of the line.
crtf_line = regex_line.search(line)
if crtf_line:
# Tries to parse the line.
# Finds info about the region.
region = regex_region.search(crtf_line.group('region'))
type_ = region.group('type') or 'reg'
include = region.group('include') or '+'
region_type = region.group('regiontype').lower()
if region_type in self.valid_definition:
helper = CRTFRegionParser(self.global_meta, include, type_, region_type,
*crtf_line.group('region', 'parameters'))
self.shapes.append(helper.shape)
else:
self._raise_error("Not a valid CRTF Region type: '{0}'.".format(region_type))
else:
self._raise_error("Not a valid CRTF line: '{0}'.".format(line))
return | python | def parse_line(self, line):
"""
Parses a single line.
"""
# Skip blanks
if line == '':
return
# Skip comments
if regex_comment.search(line):
return
# Special case / header: parse global parameters into metadata
global_parameters = regex_global.search(line)
if global_parameters:
self.parse_global_meta(global_parameters.group('parameters'))
return
# Tries to check the validity of the line.
crtf_line = regex_line.search(line)
if crtf_line:
# Tries to parse the line.
# Finds info about the region.
region = regex_region.search(crtf_line.group('region'))
type_ = region.group('type') or 'reg'
include = region.group('include') or '+'
region_type = region.group('regiontype').lower()
if region_type in self.valid_definition:
helper = CRTFRegionParser(self.global_meta, include, type_, region_type,
*crtf_line.group('region', 'parameters'))
self.shapes.append(helper.shape)
else:
self._raise_error("Not a valid CRTF Region type: '{0}'.".format(region_type))
else:
self._raise_error("Not a valid CRTF line: '{0}'.".format(line))
return | [
"def",
"parse_line",
"(",
"self",
",",
"line",
")",
":",
"if",
"line",
"==",
"''",
":",
"return",
"if",
"regex_comment",
".",
"search",
"(",
"line",
")",
":",
"return",
"global_parameters",
"=",
"regex_global",
".",
"search",
"(",
"line",
")",
"if",
"g... | Parses a single line. | [
"Parses",
"a",
"single",
"line",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/read.py#L161-L199 | train |
astropy/regions | regions/io/crtf/read.py | CRTFRegionParser.parse | def parse(self):
"""
Starting point to parse the CRTF region string.
"""
self.convert_meta()
self.coordsys = self.meta.get('coord', 'image').lower()
self.set_coordsys()
self.convert_coordinates()
self.make_shape() | python | def parse(self):
"""
Starting point to parse the CRTF region string.
"""
self.convert_meta()
self.coordsys = self.meta.get('coord', 'image').lower()
self.set_coordsys()
self.convert_coordinates()
self.make_shape() | [
"def",
"parse",
"(",
"self",
")",
":",
"self",
".",
"convert_meta",
"(",
")",
"self",
".",
"coordsys",
"=",
"self",
".",
"meta",
".",
"get",
"(",
"'coord'",
",",
"'image'",
")",
".",
"lower",
"(",
")",
"self",
".",
"set_coordsys",
"(",
")",
"self",... | Starting point to parse the CRTF region string. | [
"Starting",
"point",
"to",
"parse",
"the",
"CRTF",
"region",
"string",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/read.py#L320-L329 | train |
astropy/regions | regions/io/crtf/read.py | CRTFRegionParser.set_coordsys | def set_coordsys(self):
"""
Mapping to astropy's coordinate system name
# TODO: needs expert attention (Most reference systems are not mapped)
"""
if self.coordsys.lower() in self.coordsys_mapping:
self.coordsys = self.coordsys_mapping[self.coordsys.lower()] | python | def set_coordsys(self):
"""
Mapping to astropy's coordinate system name
# TODO: needs expert attention (Most reference systems are not mapped)
"""
if self.coordsys.lower() in self.coordsys_mapping:
self.coordsys = self.coordsys_mapping[self.coordsys.lower()] | [
"def",
"set_coordsys",
"(",
"self",
")",
":",
"if",
"self",
".",
"coordsys",
".",
"lower",
"(",
")",
"in",
"self",
".",
"coordsys_mapping",
":",
"self",
".",
"coordsys",
"=",
"self",
".",
"coordsys_mapping",
"[",
"self",
".",
"coordsys",
".",
"lower",
... | Mapping to astropy's coordinate system name
# TODO: needs expert attention (Most reference systems are not mapped) | [
"Mapping",
"to",
"astropy",
"s",
"coordinate",
"system",
"name"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/read.py#L331-L338 | train |
astropy/regions | regions/io/crtf/read.py | CRTFRegionParser.convert_coordinates | def convert_coordinates(self):
"""
Convert coordinate string to `~astropy.coordinates.Angle` or `~astropy.units.quantity.Quantity` objects
"""
coord_list_str = regex_coordinate.findall(self.reg_str) + regex_length.findall(self.reg_str)
coord_list = []
if self.region_type == 'poly':
if len(coord_list_str) < 4:
self._raise_error('Not in proper format: {} polygon should have > 4 coordinates'.format(self.reg_str))
if coord_list_str[0] != coord_list_str[-1]:
self._raise_error("Not in proper format: '{0}', "
"In polygon, the last and first coordinates should be same".format(self.reg_str))
else:
if len(coord_list_str) != len(self.language_spec[self.region_type]):
self._raise_error("Not in proper format: '{0}', "
"Does not contain expected number of parameters for the region '{1}'"
.format(self.reg_str, self.region_type))
for attr_spec, val_str in zip(self.language_spec[self.region_type], coord_list_str):
if attr_spec == 'c':
if len(val_str) == 2 and val_str[1] != '':
coord_list.append(CoordinateParser.parse_coordinate(val_str[0]))
coord_list.append(CoordinateParser.parse_coordinate(val_str[1]))
else:
self._raise_error("Not in proper format: {0} should be a coordinate".format(val_str))
if attr_spec == 'pl':
if len(val_str) == 2 and val_str[1] != '':
coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str[0]))
coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str[1]))
else:
self._raise_error("Not in proper format: {0} should be a pair of length".format(val_str))
if attr_spec == 'l':
if isinstance(val_str, six.string_types):
coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str))
else:
self._raise_error("Not in proper format: {0} should be a single length".format(val_str))
if attr_spec == 's':
if self.region_type == 'symbol':
if val_str in valid_symbols:
self.meta['symbol'] = val_str
else:
self._raise_error("Not in proper format: '{0}' should be a symbol".format(val_str))
elif self.region_type == 'text':
self.meta['text'] = val_str[1:-1]
self.coord = coord_list | python | def convert_coordinates(self):
"""
Convert coordinate string to `~astropy.coordinates.Angle` or `~astropy.units.quantity.Quantity` objects
"""
coord_list_str = regex_coordinate.findall(self.reg_str) + regex_length.findall(self.reg_str)
coord_list = []
if self.region_type == 'poly':
if len(coord_list_str) < 4:
self._raise_error('Not in proper format: {} polygon should have > 4 coordinates'.format(self.reg_str))
if coord_list_str[0] != coord_list_str[-1]:
self._raise_error("Not in proper format: '{0}', "
"In polygon, the last and first coordinates should be same".format(self.reg_str))
else:
if len(coord_list_str) != len(self.language_spec[self.region_type]):
self._raise_error("Not in proper format: '{0}', "
"Does not contain expected number of parameters for the region '{1}'"
.format(self.reg_str, self.region_type))
for attr_spec, val_str in zip(self.language_spec[self.region_type], coord_list_str):
if attr_spec == 'c':
if len(val_str) == 2 and val_str[1] != '':
coord_list.append(CoordinateParser.parse_coordinate(val_str[0]))
coord_list.append(CoordinateParser.parse_coordinate(val_str[1]))
else:
self._raise_error("Not in proper format: {0} should be a coordinate".format(val_str))
if attr_spec == 'pl':
if len(val_str) == 2 and val_str[1] != '':
coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str[0]))
coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str[1]))
else:
self._raise_error("Not in proper format: {0} should be a pair of length".format(val_str))
if attr_spec == 'l':
if isinstance(val_str, six.string_types):
coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str))
else:
self._raise_error("Not in proper format: {0} should be a single length".format(val_str))
if attr_spec == 's':
if self.region_type == 'symbol':
if val_str in valid_symbols:
self.meta['symbol'] = val_str
else:
self._raise_error("Not in proper format: '{0}' should be a symbol".format(val_str))
elif self.region_type == 'text':
self.meta['text'] = val_str[1:-1]
self.coord = coord_list | [
"def",
"convert_coordinates",
"(",
"self",
")",
":",
"coord_list_str",
"=",
"regex_coordinate",
".",
"findall",
"(",
"self",
".",
"reg_str",
")",
"+",
"regex_length",
".",
"findall",
"(",
"self",
".",
"reg_str",
")",
"coord_list",
"=",
"[",
"]",
"if",
"sel... | Convert coordinate string to `~astropy.coordinates.Angle` or `~astropy.units.quantity.Quantity` objects | [
"Convert",
"coordinate",
"string",
"to",
"~astropy",
".",
"coordinates",
".",
"Angle",
"or",
"~astropy",
".",
"units",
".",
"quantity",
".",
"Quantity",
"objects"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/read.py#L340-L387 | train |
astropy/regions | regions/io/crtf/read.py | CRTFRegionParser.convert_meta | def convert_meta(self):
"""
Parses the meta_str to python dictionary and stores in ``meta`` attribute.
"""
if self.meta_str:
self.meta_str = regex_meta.findall(self.meta_str + ',')
if self.meta_str:
for par in self.meta_str:
if par[0] is not '':
val1 = par[0]
val2 = par[1]
else:
val1 = par[2]
val2 = par[3]
val1 = val1.strip()
val2 = val2.strip()
if val1 in CRTFParser.valid_global_keys or val1 == 'label':
if val1 in ('range', 'corr', 'labeloff'):
val2 = val2.split(',')
val2 = [x.strip() for x in val2]
self.meta[val1] = val2
else:
self._raise_error("'{0}' is not a valid meta key".format(val1))
self.meta['include'] = self.include != '-'
self.include = self.meta['include']
if 'range' in self.meta:
self.meta['range'] = [u.Quantity(x) for x in self.meta['range']]
self.meta['type'] = self.type_ | python | def convert_meta(self):
"""
Parses the meta_str to python dictionary and stores in ``meta`` attribute.
"""
if self.meta_str:
self.meta_str = regex_meta.findall(self.meta_str + ',')
if self.meta_str:
for par in self.meta_str:
if par[0] is not '':
val1 = par[0]
val2 = par[1]
else:
val1 = par[2]
val2 = par[3]
val1 = val1.strip()
val2 = val2.strip()
if val1 in CRTFParser.valid_global_keys or val1 == 'label':
if val1 in ('range', 'corr', 'labeloff'):
val2 = val2.split(',')
val2 = [x.strip() for x in val2]
self.meta[val1] = val2
else:
self._raise_error("'{0}' is not a valid meta key".format(val1))
self.meta['include'] = self.include != '-'
self.include = self.meta['include']
if 'range' in self.meta:
self.meta['range'] = [u.Quantity(x) for x in self.meta['range']]
self.meta['type'] = self.type_ | [
"def",
"convert_meta",
"(",
"self",
")",
":",
"if",
"self",
".",
"meta_str",
":",
"self",
".",
"meta_str",
"=",
"regex_meta",
".",
"findall",
"(",
"self",
".",
"meta_str",
"+",
"','",
")",
"if",
"self",
".",
"meta_str",
":",
"for",
"par",
"in",
"self... | Parses the meta_str to python dictionary and stores in ``meta`` attribute. | [
"Parses",
"the",
"meta_str",
"to",
"python",
"dictionary",
"and",
"stores",
"in",
"meta",
"attribute",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/crtf/read.py#L389-L419 | train |
astropy/regions | regions/io/fits/write.py | fits_region_objects_to_table | def fits_region_objects_to_table(regions):
"""
Converts list of regions to FITS region table.
Parameters
----------
regions : list
List of `regions.Region` objects
Returns
-------
region_string : `~astropy.table.Table`
FITS region table
Examples
--------
>>> from regions import CirclePixelRegion, PixCoord
>>> reg_pixel = CirclePixelRegion(PixCoord(1, 2), 5)
>>> table = fits_region_objects_to_table([reg_pixel])
>>> print(table)
X [1] Y [1] SHAPE R [4] ROTANG COMPONENT
pix pix pix deg
----- ----- ------ ---------- ------ ---------
1.0 2.0 circle 5.0 .. 0.0 0 1
"""
for reg in regions:
if isinstance(reg, SkyRegion):
raise TypeError('Every region must be a pixel region'.format(reg))
shape_list = to_shape_list(regions, coordinate_system='image')
return shape_list.to_fits() | python | def fits_region_objects_to_table(regions):
"""
Converts list of regions to FITS region table.
Parameters
----------
regions : list
List of `regions.Region` objects
Returns
-------
region_string : `~astropy.table.Table`
FITS region table
Examples
--------
>>> from regions import CirclePixelRegion, PixCoord
>>> reg_pixel = CirclePixelRegion(PixCoord(1, 2), 5)
>>> table = fits_region_objects_to_table([reg_pixel])
>>> print(table)
X [1] Y [1] SHAPE R [4] ROTANG COMPONENT
pix pix pix deg
----- ----- ------ ---------- ------ ---------
1.0 2.0 circle 5.0 .. 0.0 0 1
"""
for reg in regions:
if isinstance(reg, SkyRegion):
raise TypeError('Every region must be a pixel region'.format(reg))
shape_list = to_shape_list(regions, coordinate_system='image')
return shape_list.to_fits() | [
"def",
"fits_region_objects_to_table",
"(",
"regions",
")",
":",
"for",
"reg",
"in",
"regions",
":",
"if",
"isinstance",
"(",
"reg",
",",
"SkyRegion",
")",
":",
"raise",
"TypeError",
"(",
"'Every region must be a pixel region'",
".",
"format",
"(",
"reg",
")",
... | Converts list of regions to FITS region table.
Parameters
----------
regions : list
List of `regions.Region` objects
Returns
-------
region_string : `~astropy.table.Table`
FITS region table
Examples
--------
>>> from regions import CirclePixelRegion, PixCoord
>>> reg_pixel = CirclePixelRegion(PixCoord(1, 2), 5)
>>> table = fits_region_objects_to_table([reg_pixel])
>>> print(table)
X [1] Y [1] SHAPE R [4] ROTANG COMPONENT
pix pix pix deg
----- ----- ------ ---------- ------ ---------
1.0 2.0 circle 5.0 .. 0.0 0 1 | [
"Converts",
"list",
"of",
"regions",
"to",
"FITS",
"region",
"table",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/fits/write.py#L15-L47 | train |
astropy/regions | regions/io/fits/write.py | write_fits_region | def write_fits_region(filename, regions, header=None):
"""
Converts list of regions to FITS region table and write to a file.
Parameters
----------
filename: str
Filename in which the table is to be written. Default is 'new.fits'
regions: list
List of `regions.Region` objects
header: `~astropy.io.fits.header.Header` object
The FITS header.
Examples
--------
>>> from astropy.utils.data import get_pkg_data_filename
>>> from astropy.io import fits
>>> file_sample = get_pkg_data_filename('data/fits_region.fits', package='regions.io.fits.tests')
>>> from regions import CirclePixelRegion, PixCoord, write_fits_region
>>> reg_pixel = CirclePixelRegion(PixCoord(1, 2), 5)
>>> hdul = fits.open(file_sample)
>>> write_fits_region('region_output.fits', regions=[reg_pixel], header=hdul[1].header)
"""
output = fits_region_objects_to_table(regions)
bin_table = fits.BinTableHDU(data=output, header=header)
bin_table.writeto(filename) | python | def write_fits_region(filename, regions, header=None):
"""
Converts list of regions to FITS region table and write to a file.
Parameters
----------
filename: str
Filename in which the table is to be written. Default is 'new.fits'
regions: list
List of `regions.Region` objects
header: `~astropy.io.fits.header.Header` object
The FITS header.
Examples
--------
>>> from astropy.utils.data import get_pkg_data_filename
>>> from astropy.io import fits
>>> file_sample = get_pkg_data_filename('data/fits_region.fits', package='regions.io.fits.tests')
>>> from regions import CirclePixelRegion, PixCoord, write_fits_region
>>> reg_pixel = CirclePixelRegion(PixCoord(1, 2), 5)
>>> hdul = fits.open(file_sample)
>>> write_fits_region('region_output.fits', regions=[reg_pixel], header=hdul[1].header)
"""
output = fits_region_objects_to_table(regions)
bin_table = fits.BinTableHDU(data=output, header=header)
bin_table.writeto(filename) | [
"def",
"write_fits_region",
"(",
"filename",
",",
"regions",
",",
"header",
"=",
"None",
")",
":",
"output",
"=",
"fits_region_objects_to_table",
"(",
"regions",
")",
"bin_table",
"=",
"fits",
".",
"BinTableHDU",
"(",
"data",
"=",
"output",
",",
"header",
"=... | Converts list of regions to FITS region table and write to a file.
Parameters
----------
filename: str
Filename in which the table is to be written. Default is 'new.fits'
regions: list
List of `regions.Region` objects
header: `~astropy.io.fits.header.Header` object
The FITS header.
Examples
--------
>>> from astropy.utils.data import get_pkg_data_filename
>>> from astropy.io import fits
>>> file_sample = get_pkg_data_filename('data/fits_region.fits', package='regions.io.fits.tests')
>>> from regions import CirclePixelRegion, PixCoord, write_fits_region
>>> reg_pixel = CirclePixelRegion(PixCoord(1, 2), 5)
>>> hdul = fits.open(file_sample)
>>> write_fits_region('region_output.fits', regions=[reg_pixel], header=hdul[1].header) | [
"Converts",
"list",
"of",
"regions",
"to",
"FITS",
"region",
"table",
"and",
"write",
"to",
"a",
"file",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/fits/write.py#L50-L78 | train |
astropy/regions | regions/_utils/examples.py | make_example_dataset | def make_example_dataset(data='simulated', config=None):
"""Make example dataset.
This is a factory function for ``ExampleDataset`` objects.
The following config options are available (default values shown):
* ``crval = 0, 0``
* ``crpix = 180, 90``
* ``cdelt = -1, 1``
* ``shape = 180, 360``
* ``ctype = 'GLON-AIT', 'GLAT-AIT'``
Parameters
----------
data : {'simulated', 'fermi'}
Which dataset to use
config : dict or None
Configuration options
Returns
-------
dataset : ``ExampleDataset``
Example dataset object
Examples
--------
Make an example dataset:
>>> from regions import make_example_dataset
>>> config = dict(crpix=(18, 9), cdelt=(-10, 10), shape=(18, 36))
>>> dataset = make_example_dataset(data='simulated', config=config)
Access properties of the ``dataset`` object:
>>> dataset.source_table
>>> dataset.event_table
>>> ExampleDataset.wcs
>>> ExampleDataset.image
>>> ExampleDataset.hdu_list
"""
if data == 'simulated':
return ExampleDatasetSimulated(config=config)
elif data == 'fermi':
return ExampleDatasetFermi(config=config)
else:
raise ValueError('Invalid selection data: {}'.format(data)) | python | def make_example_dataset(data='simulated', config=None):
"""Make example dataset.
This is a factory function for ``ExampleDataset`` objects.
The following config options are available (default values shown):
* ``crval = 0, 0``
* ``crpix = 180, 90``
* ``cdelt = -1, 1``
* ``shape = 180, 360``
* ``ctype = 'GLON-AIT', 'GLAT-AIT'``
Parameters
----------
data : {'simulated', 'fermi'}
Which dataset to use
config : dict or None
Configuration options
Returns
-------
dataset : ``ExampleDataset``
Example dataset object
Examples
--------
Make an example dataset:
>>> from regions import make_example_dataset
>>> config = dict(crpix=(18, 9), cdelt=(-10, 10), shape=(18, 36))
>>> dataset = make_example_dataset(data='simulated', config=config)
Access properties of the ``dataset`` object:
>>> dataset.source_table
>>> dataset.event_table
>>> ExampleDataset.wcs
>>> ExampleDataset.image
>>> ExampleDataset.hdu_list
"""
if data == 'simulated':
return ExampleDatasetSimulated(config=config)
elif data == 'fermi':
return ExampleDatasetFermi(config=config)
else:
raise ValueError('Invalid selection data: {}'.format(data)) | [
"def",
"make_example_dataset",
"(",
"data",
"=",
"'simulated'",
",",
"config",
"=",
"None",
")",
":",
"if",
"data",
"==",
"'simulated'",
":",
"return",
"ExampleDatasetSimulated",
"(",
"config",
"=",
"config",
")",
"elif",
"data",
"==",
"'fermi'",
":",
"retur... | Make example dataset.
This is a factory function for ``ExampleDataset`` objects.
The following config options are available (default values shown):
* ``crval = 0, 0``
* ``crpix = 180, 90``
* ``cdelt = -1, 1``
* ``shape = 180, 360``
* ``ctype = 'GLON-AIT', 'GLAT-AIT'``
Parameters
----------
data : {'simulated', 'fermi'}
Which dataset to use
config : dict or None
Configuration options
Returns
-------
dataset : ``ExampleDataset``
Example dataset object
Examples
--------
Make an example dataset:
>>> from regions import make_example_dataset
>>> config = dict(crpix=(18, 9), cdelt=(-10, 10), shape=(18, 36))
>>> dataset = make_example_dataset(data='simulated', config=config)
Access properties of the ``dataset`` object:
>>> dataset.source_table
>>> dataset.event_table
>>> ExampleDataset.wcs
>>> ExampleDataset.image
>>> ExampleDataset.hdu_list | [
"Make",
"example",
"dataset",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/_utils/examples.py#L17-L64 | train |
astropy/regions | regions/_utils/examples.py | _table_to_bintable | def _table_to_bintable(table):
"""Convert `~astropy.table.Table` to `astropy.io.fits.BinTable`."""
data = table.as_array()
header = fits.Header()
header.update(table.meta)
name = table.meta.pop('name', None)
return fits.BinTableHDU(data, header, name=name) | python | def _table_to_bintable(table):
"""Convert `~astropy.table.Table` to `astropy.io.fits.BinTable`."""
data = table.as_array()
header = fits.Header()
header.update(table.meta)
name = table.meta.pop('name', None)
return fits.BinTableHDU(data, header, name=name) | [
"def",
"_table_to_bintable",
"(",
"table",
")",
":",
"data",
"=",
"table",
".",
"as_array",
"(",
")",
"header",
"=",
"fits",
".",
"Header",
"(",
")",
"header",
".",
"update",
"(",
"table",
".",
"meta",
")",
"name",
"=",
"table",
".",
"meta",
".",
"... | Convert `~astropy.table.Table` to `astropy.io.fits.BinTable`. | [
"Convert",
"~astropy",
".",
"table",
".",
"Table",
"to",
"astropy",
".",
"io",
".",
"fits",
".",
"BinTable",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/_utils/examples.py#L223-L229 | train |
astropy/regions | regions/io/ds9/read.py | read_ds9 | def read_ds9(filename, errors='strict'):
"""
Read a DS9 region file in as a `list` of `~regions.Region` objects.
Parameters
----------
filename : `str`
The file path
errors : ``warn``, ``ignore``, ``strict``, optional
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `~regions.DS9RegionParserError`.
``warn`` will raise a `~regions.DS9RegionParserWarning`, and
``ignore`` will do nothing (i.e., be silent).
Returns
-------
regions : `list`
Python list of `~regions.Region` objects.
Examples
--------
>>> from regions import read_ds9
>>> from astropy.utils.data import get_pkg_data_filename
>>> file = get_pkg_data_filename('data/physical_reference.reg', package='regions.io.ds9.tests')
>>> regs = read_ds9(file, errors='warn')
>>> print(regs[0])
Region: CirclePixelRegion
center: PixCoord(x=330.0, y=1090.0)
radius: 40.0
>>> print(regs[0].meta)
{'label': 'Circle', 'select': '1', 'highlite': '1', 'fixed': '0', 'edit': '1', 'move': '1', 'delete': '1', 'source': '1', 'tag': ['{foo}', '{foo bar}'], 'include': True}
>>> print(regs[0].visual)
{'dashlist': '8 3', 'dash': '0', 'color': 'pink', 'linewidth': '3', 'font': 'times', 'fontsize': '10', 'fontstyle': 'normal', 'fontweight': 'roman'}
"""
with open(filename) as fh:
region_string = fh.read()
parser = DS9Parser(region_string, errors=errors)
return parser.shapes.to_regions() | python | def read_ds9(filename, errors='strict'):
"""
Read a DS9 region file in as a `list` of `~regions.Region` objects.
Parameters
----------
filename : `str`
The file path
errors : ``warn``, ``ignore``, ``strict``, optional
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `~regions.DS9RegionParserError`.
``warn`` will raise a `~regions.DS9RegionParserWarning`, and
``ignore`` will do nothing (i.e., be silent).
Returns
-------
regions : `list`
Python list of `~regions.Region` objects.
Examples
--------
>>> from regions import read_ds9
>>> from astropy.utils.data import get_pkg_data_filename
>>> file = get_pkg_data_filename('data/physical_reference.reg', package='regions.io.ds9.tests')
>>> regs = read_ds9(file, errors='warn')
>>> print(regs[0])
Region: CirclePixelRegion
center: PixCoord(x=330.0, y=1090.0)
radius: 40.0
>>> print(regs[0].meta)
{'label': 'Circle', 'select': '1', 'highlite': '1', 'fixed': '0', 'edit': '1', 'move': '1', 'delete': '1', 'source': '1', 'tag': ['{foo}', '{foo bar}'], 'include': True}
>>> print(regs[0].visual)
{'dashlist': '8 3', 'dash': '0', 'color': 'pink', 'linewidth': '3', 'font': 'times', 'fontsize': '10', 'fontstyle': 'normal', 'fontweight': 'roman'}
"""
with open(filename) as fh:
region_string = fh.read()
parser = DS9Parser(region_string, errors=errors)
return parser.shapes.to_regions() | [
"def",
"read_ds9",
"(",
"filename",
",",
"errors",
"=",
"'strict'",
")",
":",
"with",
"open",
"(",
"filename",
")",
"as",
"fh",
":",
"region_string",
"=",
"fh",
".",
"read",
"(",
")",
"parser",
"=",
"DS9Parser",
"(",
"region_string",
",",
"errors",
"="... | Read a DS9 region file in as a `list` of `~regions.Region` objects.
Parameters
----------
filename : `str`
The file path
errors : ``warn``, ``ignore``, ``strict``, optional
The error handling scheme to use for handling parsing errors.
The default is 'strict', which will raise a `~regions.DS9RegionParserError`.
``warn`` will raise a `~regions.DS9RegionParserWarning`, and
``ignore`` will do nothing (i.e., be silent).
Returns
-------
regions : `list`
Python list of `~regions.Region` objects.
Examples
--------
>>> from regions import read_ds9
>>> from astropy.utils.data import get_pkg_data_filename
>>> file = get_pkg_data_filename('data/physical_reference.reg', package='regions.io.ds9.tests')
>>> regs = read_ds9(file, errors='warn')
>>> print(regs[0])
Region: CirclePixelRegion
center: PixCoord(x=330.0, y=1090.0)
radius: 40.0
>>> print(regs[0].meta)
{'label': 'Circle', 'select': '1', 'highlite': '1', 'fixed': '0', 'edit': '1', 'move': '1', 'delete': '1', 'source': '1', 'tag': ['{foo}', '{foo bar}'], 'include': True}
>>> print(regs[0].visual)
{'dashlist': '8 3', 'dash': '0', 'color': 'pink', 'linewidth': '3', 'font': 'times', 'fontsize': '10', 'fontstyle': 'normal', 'fontweight': 'roman'} | [
"Read",
"a",
"DS9",
"region",
"file",
"in",
"as",
"a",
"list",
"of",
"~regions",
".",
"Region",
"objects",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L38-L77 | train |
astropy/regions | regions/io/ds9/read.py | DS9Parser.set_coordsys | def set_coordsys(self, coordsys):
"""
Transform coordinate system
# TODO: needs expert attention
"""
if coordsys in self.coordsys_mapping:
self.coordsys = self.coordsys_mapping[coordsys]
else:
self.coordsys = coordsys | python | def set_coordsys(self, coordsys):
"""
Transform coordinate system
# TODO: needs expert attention
"""
if coordsys in self.coordsys_mapping:
self.coordsys = self.coordsys_mapping[coordsys]
else:
self.coordsys = coordsys | [
"def",
"set_coordsys",
"(",
"self",
",",
"coordsys",
")",
":",
"if",
"coordsys",
"in",
"self",
".",
"coordsys_mapping",
":",
"self",
".",
"coordsys",
"=",
"self",
".",
"coordsys_mapping",
"[",
"coordsys",
"]",
"else",
":",
"self",
".",
"coordsys",
"=",
"... | Transform coordinate system
# TODO: needs expert attention | [
"Transform",
"coordinate",
"system"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L215-L224 | train |
astropy/regions | regions/io/ds9/read.py | DS9Parser.run | def run(self):
"""
Run all steps
"""
for line_ in self.region_string.split('\n'):
for line in line_.split(";"):
self.parse_line(line)
log.debug('Global state: {}'.format(self)) | python | def run(self):
"""
Run all steps
"""
for line_ in self.region_string.split('\n'):
for line in line_.split(";"):
self.parse_line(line)
log.debug('Global state: {}'.format(self)) | [
"def",
"run",
"(",
"self",
")",
":",
"for",
"line_",
"in",
"self",
".",
"region_string",
".",
"split",
"(",
"'\\n'",
")",
":",
"for",
"line",
"in",
"line_",
".",
"split",
"(",
"\";\"",
")",
":",
"self",
".",
"parse_line",
"(",
"line",
")",
"log",
... | Run all steps | [
"Run",
"all",
"steps"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L226-L233 | train |
astropy/regions | regions/io/ds9/read.py | DS9Parser.parse_meta | def parse_meta(meta_str):
"""
Parse the metadata for a single ds9 region string.
Parameters
----------
meta_str : `str`
Meta string, the metadata is everything after the close-paren of the
region coordinate specification. All metadata is specified as
key=value pairs separated by whitespace, but sometimes the values
can also be whitespace separated.
Returns
-------
meta : `~collections.OrderedDict`
Dictionary containing the meta data
"""
keys_vals = [(x, y) for x, _, y in regex_meta.findall(meta_str.strip())]
extra_text = regex_meta.split(meta_str.strip())[-1]
result = OrderedDict()
for key, val in keys_vals:
# regex can include trailing whitespace or inverted commas
# remove it
val = val.strip().strip("'").strip('"')
if key == 'text':
val = val.lstrip("{").rstrip("}")
if key in result:
if key == 'tag':
result[key].append(val)
else:
raise ValueError("Duplicate key {0} found".format(key))
else:
if key == 'tag':
result[key] = [val]
else:
result[key] = val
if extra_text:
result['comment'] = extra_text
return result | python | def parse_meta(meta_str):
"""
Parse the metadata for a single ds9 region string.
Parameters
----------
meta_str : `str`
Meta string, the metadata is everything after the close-paren of the
region coordinate specification. All metadata is specified as
key=value pairs separated by whitespace, but sometimes the values
can also be whitespace separated.
Returns
-------
meta : `~collections.OrderedDict`
Dictionary containing the meta data
"""
keys_vals = [(x, y) for x, _, y in regex_meta.findall(meta_str.strip())]
extra_text = regex_meta.split(meta_str.strip())[-1]
result = OrderedDict()
for key, val in keys_vals:
# regex can include trailing whitespace or inverted commas
# remove it
val = val.strip().strip("'").strip('"')
if key == 'text':
val = val.lstrip("{").rstrip("}")
if key in result:
if key == 'tag':
result[key].append(val)
else:
raise ValueError("Duplicate key {0} found".format(key))
else:
if key == 'tag':
result[key] = [val]
else:
result[key] = val
if extra_text:
result['comment'] = extra_text
return result | [
"def",
"parse_meta",
"(",
"meta_str",
")",
":",
"keys_vals",
"=",
"[",
"(",
"x",
",",
"y",
")",
"for",
"x",
",",
"_",
",",
"y",
"in",
"regex_meta",
".",
"findall",
"(",
"meta_str",
".",
"strip",
"(",
")",
")",
"]",
"extra_text",
"=",
"regex_meta",
... | Parse the metadata for a single ds9 region string.
Parameters
----------
meta_str : `str`
Meta string, the metadata is everything after the close-paren of the
region coordinate specification. All metadata is specified as
key=value pairs separated by whitespace, but sometimes the values
can also be whitespace separated.
Returns
-------
meta : `~collections.OrderedDict`
Dictionary containing the meta data | [
"Parse",
"the",
"metadata",
"for",
"a",
"single",
"ds9",
"region",
"string",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L288-L327 | train |
astropy/regions | regions/io/ds9/read.py | DS9Parser.parse_region | def parse_region(self, include, region_type, region_end, line):
"""
Extract a Shape from a region string
"""
if self.coordsys is None:
raise DS9RegionParserError("No coordinate system specified and a"
" region has been found.")
else:
helper = DS9RegionParser(coordsys=self.coordsys,
include=include,
region_type=region_type,
region_end=region_end,
global_meta=self.global_meta,
line=line)
helper.parse()
self.shapes.append(helper.shape) | python | def parse_region(self, include, region_type, region_end, line):
"""
Extract a Shape from a region string
"""
if self.coordsys is None:
raise DS9RegionParserError("No coordinate system specified and a"
" region has been found.")
else:
helper = DS9RegionParser(coordsys=self.coordsys,
include=include,
region_type=region_type,
region_end=region_end,
global_meta=self.global_meta,
line=line)
helper.parse()
self.shapes.append(helper.shape) | [
"def",
"parse_region",
"(",
"self",
",",
"include",
",",
"region_type",
",",
"region_end",
",",
"line",
")",
":",
"if",
"self",
".",
"coordsys",
"is",
"None",
":",
"raise",
"DS9RegionParserError",
"(",
"\"No coordinate system specified and a\"",
"\" region has been ... | Extract a Shape from a region string | [
"Extract",
"a",
"Shape",
"from",
"a",
"region",
"string"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L329-L344 | train |
astropy/regions | regions/io/ds9/read.py | DS9RegionParser.parse | def parse(self):
"""
Convert line to shape object
"""
log.debug(self)
self.parse_composite()
self.split_line()
self.convert_coordinates()
self.convert_meta()
self.make_shape()
log.debug(self) | python | def parse(self):
"""
Convert line to shape object
"""
log.debug(self)
self.parse_composite()
self.split_line()
self.convert_coordinates()
self.convert_meta()
self.make_shape()
log.debug(self) | [
"def",
"parse",
"(",
"self",
")",
":",
"log",
".",
"debug",
"(",
"self",
")",
"self",
".",
"parse_composite",
"(",
")",
"self",
".",
"split_line",
"(",
")",
"self",
".",
"convert_coordinates",
"(",
")",
"self",
".",
"convert_meta",
"(",
")",
"self",
... | Convert line to shape object | [
"Convert",
"line",
"to",
"shape",
"object"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L431-L442 | train |
astropy/regions | regions/io/ds9/read.py | DS9RegionParser.split_line | def split_line(self):
"""
Split line into coordinates and meta string
"""
# coordinate of the # symbol or end of the line (-1) if not found
hash_or_end = self.line.find("#")
temp = self.line[self.region_end:hash_or_end].strip(" |")
self.coord_str = regex_paren.sub("", temp)
# don't want any meta_str if there is no metadata found
if hash_or_end >= 0:
self.meta_str = self.line[hash_or_end:]
else:
self.meta_str = "" | python | def split_line(self):
"""
Split line into coordinates and meta string
"""
# coordinate of the # symbol or end of the line (-1) if not found
hash_or_end = self.line.find("#")
temp = self.line[self.region_end:hash_or_end].strip(" |")
self.coord_str = regex_paren.sub("", temp)
# don't want any meta_str if there is no metadata found
if hash_or_end >= 0:
self.meta_str = self.line[hash_or_end:]
else:
self.meta_str = "" | [
"def",
"split_line",
"(",
"self",
")",
":",
"hash_or_end",
"=",
"self",
".",
"line",
".",
"find",
"(",
"\"#\"",
")",
"temp",
"=",
"self",
".",
"line",
"[",
"self",
".",
"region_end",
":",
"hash_or_end",
"]",
".",
"strip",
"(",
"\" |\"",
")",
"self",
... | Split line into coordinates and meta string | [
"Split",
"line",
"into",
"coordinates",
"and",
"meta",
"string"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L450-L463 | train |
astropy/regions | regions/io/ds9/read.py | DS9RegionParser.convert_coordinates | def convert_coordinates(self):
"""
Convert coordinate string to objects
"""
coord_list = []
# strip out "null" elements, i.e. ''. It might be possible to eliminate
# these some other way, i.e. with regex directly, but I don't know how.
# We need to copy in order not to burn up the iterators
elements = [x for x in regex_splitter.split(self.coord_str) if x]
element_parsers = self.language_spec[self.region_type]
for ii, (element, element_parser) in enumerate(zip(elements,
element_parsers)):
if element_parser is coordinate:
unit = self.coordinate_units[self.coordsys][ii % 2]
coord_list.append(element_parser(element, unit))
elif self.coordinate_units[self.coordsys][0] is u.dimensionless_unscaled:
coord_list.append(element_parser(element, unit=u.dimensionless_unscaled))
else:
coord_list.append(element_parser(element))
if self.region_type in ['ellipse', 'box'] and len(coord_list) % 2 == 1:
coord_list[-1] = CoordinateParser.parse_angular_length_quantity(elements[len(coord_list)-1])
# Reset iterator for ellipse and annulus
# Note that this cannot be done with copy.deepcopy on python2
if self.region_type in ['ellipse', 'annulus']:
self.language_spec[self.region_type] = itertools.chain(
(coordinate, coordinate), itertools.cycle((radius,)))
self.coord = coord_list | python | def convert_coordinates(self):
"""
Convert coordinate string to objects
"""
coord_list = []
# strip out "null" elements, i.e. ''. It might be possible to eliminate
# these some other way, i.e. with regex directly, but I don't know how.
# We need to copy in order not to burn up the iterators
elements = [x for x in regex_splitter.split(self.coord_str) if x]
element_parsers = self.language_spec[self.region_type]
for ii, (element, element_parser) in enumerate(zip(elements,
element_parsers)):
if element_parser is coordinate:
unit = self.coordinate_units[self.coordsys][ii % 2]
coord_list.append(element_parser(element, unit))
elif self.coordinate_units[self.coordsys][0] is u.dimensionless_unscaled:
coord_list.append(element_parser(element, unit=u.dimensionless_unscaled))
else:
coord_list.append(element_parser(element))
if self.region_type in ['ellipse', 'box'] and len(coord_list) % 2 == 1:
coord_list[-1] = CoordinateParser.parse_angular_length_quantity(elements[len(coord_list)-1])
# Reset iterator for ellipse and annulus
# Note that this cannot be done with copy.deepcopy on python2
if self.region_type in ['ellipse', 'annulus']:
self.language_spec[self.region_type] = itertools.chain(
(coordinate, coordinate), itertools.cycle((radius,)))
self.coord = coord_list | [
"def",
"convert_coordinates",
"(",
"self",
")",
":",
"coord_list",
"=",
"[",
"]",
"elements",
"=",
"[",
"x",
"for",
"x",
"in",
"regex_splitter",
".",
"split",
"(",
"self",
".",
"coord_str",
")",
"if",
"x",
"]",
"element_parsers",
"=",
"self",
".",
"lan... | Convert coordinate string to objects | [
"Convert",
"coordinate",
"string",
"to",
"objects"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L465-L494 | train |
astropy/regions | regions/io/ds9/read.py | DS9RegionParser.convert_meta | def convert_meta(self):
"""
Convert meta string to dict
"""
meta_ = DS9Parser.parse_meta(self.meta_str)
self.meta = copy.deepcopy(self.global_meta)
self.meta.update(meta_)
# the 'include' is not part of the metadata string;
# it is pre-parsed as part of the shape type and should always
# override the global one
self.include = self.meta.get('include', True) if self.include == '' else self.include != '-'
self.meta['include'] = self.include | python | def convert_meta(self):
"""
Convert meta string to dict
"""
meta_ = DS9Parser.parse_meta(self.meta_str)
self.meta = copy.deepcopy(self.global_meta)
self.meta.update(meta_)
# the 'include' is not part of the metadata string;
# it is pre-parsed as part of the shape type and should always
# override the global one
self.include = self.meta.get('include', True) if self.include == '' else self.include != '-'
self.meta['include'] = self.include | [
"def",
"convert_meta",
"(",
"self",
")",
":",
"meta_",
"=",
"DS9Parser",
".",
"parse_meta",
"(",
"self",
".",
"meta_str",
")",
"self",
".",
"meta",
"=",
"copy",
".",
"deepcopy",
"(",
"self",
".",
"global_meta",
")",
"self",
".",
"meta",
".",
"update",
... | Convert meta string to dict | [
"Convert",
"meta",
"string",
"to",
"dict"
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/io/ds9/read.py#L496-L507 | train |
astropy/regions | regions/core/pixcoord.py | PixCoord._validate | def _validate(val, name, expected='any'):
"""Validate that a given object is an appropriate `PixCoord`.
This is used for input validation throughout the regions package,
especially in the `__init__` method of pixel region classes.
Parameters
----------
val : `PixCoord`
The object to check
name : str
Parameter name (used for error messages)
expected : {'any', 'scalar', 'not scalar'}
What kind of PixCoord to check for
Returns
-------
val : `PixCoord`
The input object (at the moment unmodified, might do fix-ups here later)
"""
if not isinstance(val, PixCoord):
raise TypeError('{} must be a PixCoord'.format(name))
if expected == 'any':
pass
elif expected == 'scalar':
if not val.isscalar:
raise ValueError('{} must be a scalar PixCoord'.format(name))
elif expected == 'not scalar':
if val.isscalar:
raise ValueError('{} must be a non-scalar PixCoord'.format(name))
else:
raise ValueError('Invalid argument for `expected`: {}'.format(expected))
return val | python | def _validate(val, name, expected='any'):
"""Validate that a given object is an appropriate `PixCoord`.
This is used for input validation throughout the regions package,
especially in the `__init__` method of pixel region classes.
Parameters
----------
val : `PixCoord`
The object to check
name : str
Parameter name (used for error messages)
expected : {'any', 'scalar', 'not scalar'}
What kind of PixCoord to check for
Returns
-------
val : `PixCoord`
The input object (at the moment unmodified, might do fix-ups here later)
"""
if not isinstance(val, PixCoord):
raise TypeError('{} must be a PixCoord'.format(name))
if expected == 'any':
pass
elif expected == 'scalar':
if not val.isscalar:
raise ValueError('{} must be a scalar PixCoord'.format(name))
elif expected == 'not scalar':
if val.isscalar:
raise ValueError('{} must be a non-scalar PixCoord'.format(name))
else:
raise ValueError('Invalid argument for `expected`: {}'.format(expected))
return val | [
"def",
"_validate",
"(",
"val",
",",
"name",
",",
"expected",
"=",
"'any'",
")",
":",
"if",
"not",
"isinstance",
"(",
"val",
",",
"PixCoord",
")",
":",
"raise",
"TypeError",
"(",
"'{} must be a PixCoord'",
".",
"format",
"(",
"name",
")",
")",
"if",
"e... | Validate that a given object is an appropriate `PixCoord`.
This is used for input validation throughout the regions package,
especially in the `__init__` method of pixel region classes.
Parameters
----------
val : `PixCoord`
The object to check
name : str
Parameter name (used for error messages)
expected : {'any', 'scalar', 'not scalar'}
What kind of PixCoord to check for
Returns
-------
val : `PixCoord`
The input object (at the moment unmodified, might do fix-ups here later) | [
"Validate",
"that",
"a",
"given",
"object",
"is",
"an",
"appropriate",
"PixCoord",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/core/pixcoord.py#L45-L79 | train |
astropy/regions | regions/core/pixcoord.py | PixCoord.to_sky | def to_sky(self, wcs, origin=_DEFAULT_WCS_ORIGIN, mode=_DEFAULT_WCS_MODE):
"""Convert this `PixCoord` to `~astropy.coordinates.SkyCoord`.
Calls :meth:`astropy.coordinates.SkyCoord.from_pixel`.
See parameter description there.
"""
return SkyCoord.from_pixel(
xp=self.x, yp=self.y, wcs=wcs,
origin=origin, mode=mode,
) | python | def to_sky(self, wcs, origin=_DEFAULT_WCS_ORIGIN, mode=_DEFAULT_WCS_MODE):
"""Convert this `PixCoord` to `~astropy.coordinates.SkyCoord`.
Calls :meth:`astropy.coordinates.SkyCoord.from_pixel`.
See parameter description there.
"""
return SkyCoord.from_pixel(
xp=self.x, yp=self.y, wcs=wcs,
origin=origin, mode=mode,
) | [
"def",
"to_sky",
"(",
"self",
",",
"wcs",
",",
"origin",
"=",
"_DEFAULT_WCS_ORIGIN",
",",
"mode",
"=",
"_DEFAULT_WCS_MODE",
")",
":",
"return",
"SkyCoord",
".",
"from_pixel",
"(",
"xp",
"=",
"self",
".",
"x",
",",
"yp",
"=",
"self",
".",
"y",
",",
"w... | Convert this `PixCoord` to `~astropy.coordinates.SkyCoord`.
Calls :meth:`astropy.coordinates.SkyCoord.from_pixel`.
See parameter description there. | [
"Convert",
"this",
"PixCoord",
"to",
"~astropy",
".",
"coordinates",
".",
"SkyCoord",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/core/pixcoord.py#L123-L132 | train |
astropy/regions | regions/core/pixcoord.py | PixCoord.from_sky | def from_sky(cls, skycoord, wcs, origin=_DEFAULT_WCS_ORIGIN, mode=_DEFAULT_WCS_MODE):
"""Create `PixCoord` from `~astropy.coordinates.SkyCoord`.
Calls :meth:`astropy.coordinates.SkyCoord.to_pixel`.
See parameter description there.
"""
x, y = skycoord.to_pixel(wcs=wcs, origin=origin, mode=mode)
return cls(x=x, y=y) | python | def from_sky(cls, skycoord, wcs, origin=_DEFAULT_WCS_ORIGIN, mode=_DEFAULT_WCS_MODE):
"""Create `PixCoord` from `~astropy.coordinates.SkyCoord`.
Calls :meth:`astropy.coordinates.SkyCoord.to_pixel`.
See parameter description there.
"""
x, y = skycoord.to_pixel(wcs=wcs, origin=origin, mode=mode)
return cls(x=x, y=y) | [
"def",
"from_sky",
"(",
"cls",
",",
"skycoord",
",",
"wcs",
",",
"origin",
"=",
"_DEFAULT_WCS_ORIGIN",
",",
"mode",
"=",
"_DEFAULT_WCS_MODE",
")",
":",
"x",
",",
"y",
"=",
"skycoord",
".",
"to_pixel",
"(",
"wcs",
"=",
"wcs",
",",
"origin",
"=",
"origin... | Create `PixCoord` from `~astropy.coordinates.SkyCoord`.
Calls :meth:`astropy.coordinates.SkyCoord.to_pixel`.
See parameter description there. | [
"Create",
"PixCoord",
"from",
"~astropy",
".",
"coordinates",
".",
"SkyCoord",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/core/pixcoord.py#L135-L142 | train |
astropy/regions | regions/core/pixcoord.py | PixCoord.separation | def separation(self, other):
r"""Separation to another pixel coordinate.
This is the two-dimensional cartesian separation :math:`d` with
.. math::
d = \sqrt{(x_1 - x_2) ^ 2 + (y_1 - y_2) ^ 2}
Parameters
----------
other : `PixCoord`
Other pixel coordinate
Returns
-------
separation : `numpy.array`
Separation in pixels
"""
dx = other.x - self.x
dy = other.y - self.y
return np.hypot(dx, dy) | python | def separation(self, other):
r"""Separation to another pixel coordinate.
This is the two-dimensional cartesian separation :math:`d` with
.. math::
d = \sqrt{(x_1 - x_2) ^ 2 + (y_1 - y_2) ^ 2}
Parameters
----------
other : `PixCoord`
Other pixel coordinate
Returns
-------
separation : `numpy.array`
Separation in pixels
"""
dx = other.x - self.x
dy = other.y - self.y
return np.hypot(dx, dy) | [
"def",
"separation",
"(",
"self",
",",
"other",
")",
":",
"r",
"dx",
"=",
"other",
".",
"x",
"-",
"self",
".",
"x",
"dy",
"=",
"other",
".",
"y",
"-",
"self",
".",
"y",
"return",
"np",
".",
"hypot",
"(",
"dx",
",",
"dy",
")"
] | r"""Separation to another pixel coordinate.
This is the two-dimensional cartesian separation :math:`d` with
.. math::
d = \sqrt{(x_1 - x_2) ^ 2 + (y_1 - y_2) ^ 2}
Parameters
----------
other : `PixCoord`
Other pixel coordinate
Returns
-------
separation : `numpy.array`
Separation in pixels | [
"r",
"Separation",
"to",
"another",
"pixel",
"coordinate",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/core/pixcoord.py#L144-L164 | train |
astropy/regions | regions/_utils/wcs_helpers.py | skycoord_to_pixel_scale_angle | def skycoord_to_pixel_scale_angle(skycoord, wcs, small_offset=1 * u.arcsec):
"""
Convert a set of SkyCoord coordinates into pixel coordinates, pixel
scales, and position angles.
Parameters
----------
skycoord : `~astropy.coordinates.SkyCoord`
Sky coordinates
wcs : `~astropy.wcs.WCS`
The WCS transformation to use
small_offset : `~astropy.units.Quantity`
A small offset to use to compute the angle
Returns
-------
pixcoord : `~regions.PixCoord`
Pixel coordinates
scale : float
The pixel scale at each location, in degrees/pixel
angle : `~astropy.units.Quantity`
The position angle of the celestial coordinate system in pixel space.
"""
# Convert to pixel coordinates
x, y = skycoord_to_pixel(skycoord, wcs, mode=skycoord_to_pixel_mode)
pixcoord = PixCoord(x=x, y=y)
# We take a point directly 'above' (in latitude) the position requested
# and convert it to pixel coordinates, then we use that to figure out the
# scale and position angle of the coordinate system at the location of
# the points.
# Find the coordinates as a representation object
r_old = skycoord.represent_as('unitspherical')
# Add a a small perturbation in the latitude direction (since longitude
# is more difficult because it is not directly an angle).
dlat = small_offset
r_new = UnitSphericalRepresentation(r_old.lon, r_old.lat + dlat)
coords_offset = skycoord.realize_frame(r_new)
# Find pixel coordinates of offset coordinates
x_offset, y_offset = skycoord_to_pixel(coords_offset, wcs,
mode=skycoord_to_pixel_mode)
# Find vector
dx = x_offset - x
dy = y_offset - y
# Find the length of the vector
scale = np.hypot(dx, dy) / dlat.to('degree').value
# Find the position angle
angle = np.arctan2(dy, dx) * u.radian
return pixcoord, scale, angle | python | def skycoord_to_pixel_scale_angle(skycoord, wcs, small_offset=1 * u.arcsec):
"""
Convert a set of SkyCoord coordinates into pixel coordinates, pixel
scales, and position angles.
Parameters
----------
skycoord : `~astropy.coordinates.SkyCoord`
Sky coordinates
wcs : `~astropy.wcs.WCS`
The WCS transformation to use
small_offset : `~astropy.units.Quantity`
A small offset to use to compute the angle
Returns
-------
pixcoord : `~regions.PixCoord`
Pixel coordinates
scale : float
The pixel scale at each location, in degrees/pixel
angle : `~astropy.units.Quantity`
The position angle of the celestial coordinate system in pixel space.
"""
# Convert to pixel coordinates
x, y = skycoord_to_pixel(skycoord, wcs, mode=skycoord_to_pixel_mode)
pixcoord = PixCoord(x=x, y=y)
# We take a point directly 'above' (in latitude) the position requested
# and convert it to pixel coordinates, then we use that to figure out the
# scale and position angle of the coordinate system at the location of
# the points.
# Find the coordinates as a representation object
r_old = skycoord.represent_as('unitspherical')
# Add a a small perturbation in the latitude direction (since longitude
# is more difficult because it is not directly an angle).
dlat = small_offset
r_new = UnitSphericalRepresentation(r_old.lon, r_old.lat + dlat)
coords_offset = skycoord.realize_frame(r_new)
# Find pixel coordinates of offset coordinates
x_offset, y_offset = skycoord_to_pixel(coords_offset, wcs,
mode=skycoord_to_pixel_mode)
# Find vector
dx = x_offset - x
dy = y_offset - y
# Find the length of the vector
scale = np.hypot(dx, dy) / dlat.to('degree').value
# Find the position angle
angle = np.arctan2(dy, dx) * u.radian
return pixcoord, scale, angle | [
"def",
"skycoord_to_pixel_scale_angle",
"(",
"skycoord",
",",
"wcs",
",",
"small_offset",
"=",
"1",
"*",
"u",
".",
"arcsec",
")",
":",
"x",
",",
"y",
"=",
"skycoord_to_pixel",
"(",
"skycoord",
",",
"wcs",
",",
"mode",
"=",
"skycoord_to_pixel_mode",
")",
"p... | Convert a set of SkyCoord coordinates into pixel coordinates, pixel
scales, and position angles.
Parameters
----------
skycoord : `~astropy.coordinates.SkyCoord`
Sky coordinates
wcs : `~astropy.wcs.WCS`
The WCS transformation to use
small_offset : `~astropy.units.Quantity`
A small offset to use to compute the angle
Returns
-------
pixcoord : `~regions.PixCoord`
Pixel coordinates
scale : float
The pixel scale at each location, in degrees/pixel
angle : `~astropy.units.Quantity`
The position angle of the celestial coordinate system in pixel space. | [
"Convert",
"a",
"set",
"of",
"SkyCoord",
"coordinates",
"into",
"pixel",
"coordinates",
"pixel",
"scales",
"and",
"position",
"angles",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/_utils/wcs_helpers.py#L13-L69 | train |
astropy/regions | regions/_utils/wcs_helpers.py | assert_angle | def assert_angle(name, q):
"""
Check that ``q`` is an angular `~astropy.units.Quantity`.
"""
if isinstance(q, u.Quantity):
if q.unit.physical_type == 'angle':
pass
else:
raise ValueError("{0} should have angular units".format(name))
else:
raise TypeError("{0} should be a Quantity instance".format(name)) | python | def assert_angle(name, q):
"""
Check that ``q`` is an angular `~astropy.units.Quantity`.
"""
if isinstance(q, u.Quantity):
if q.unit.physical_type == 'angle':
pass
else:
raise ValueError("{0} should have angular units".format(name))
else:
raise TypeError("{0} should be a Quantity instance".format(name)) | [
"def",
"assert_angle",
"(",
"name",
",",
"q",
")",
":",
"if",
"isinstance",
"(",
"q",
",",
"u",
".",
"Quantity",
")",
":",
"if",
"q",
".",
"unit",
".",
"physical_type",
"==",
"'angle'",
":",
"pass",
"else",
":",
"raise",
"ValueError",
"(",
"\"{0} sho... | Check that ``q`` is an angular `~astropy.units.Quantity`. | [
"Check",
"that",
"q",
"is",
"an",
"angular",
"~astropy",
".",
"units",
".",
"Quantity",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/regions/_utils/wcs_helpers.py#L86-L96 | train |
astropy/regions | ah_bootstrap.py | _silence | def _silence():
"""A context manager that silences sys.stdout and sys.stderr."""
old_stdout = sys.stdout
old_stderr = sys.stderr
sys.stdout = _DummyFile()
sys.stderr = _DummyFile()
exception_occurred = False
try:
yield
except:
exception_occurred = True
# Go ahead and clean up so that exception handling can work normally
sys.stdout = old_stdout
sys.stderr = old_stderr
raise
if not exception_occurred:
sys.stdout = old_stdout
sys.stderr = old_stderr | python | def _silence():
"""A context manager that silences sys.stdout and sys.stderr."""
old_stdout = sys.stdout
old_stderr = sys.stderr
sys.stdout = _DummyFile()
sys.stderr = _DummyFile()
exception_occurred = False
try:
yield
except:
exception_occurred = True
# Go ahead and clean up so that exception handling can work normally
sys.stdout = old_stdout
sys.stderr = old_stderr
raise
if not exception_occurred:
sys.stdout = old_stdout
sys.stderr = old_stderr | [
"def",
"_silence",
"(",
")",
":",
"old_stdout",
"=",
"sys",
".",
"stdout",
"old_stderr",
"=",
"sys",
".",
"stderr",
"sys",
".",
"stdout",
"=",
"_DummyFile",
"(",
")",
"sys",
".",
"stderr",
"=",
"_DummyFile",
"(",
")",
"exception_occurred",
"=",
"False",
... | A context manager that silences sys.stdout and sys.stderr. | [
"A",
"context",
"manager",
"that",
"silences",
"sys",
".",
"stdout",
"and",
"sys",
".",
"stderr",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/ah_bootstrap.py#L914-L933 | train |
astropy/regions | ah_bootstrap.py | use_astropy_helpers | def use_astropy_helpers(**kwargs):
"""
Ensure that the `astropy_helpers` module is available and is importable.
This supports automatic submodule initialization if astropy_helpers is
included in a project as a git submodule, or will download it from PyPI if
necessary.
Parameters
----------
path : str or None, optional
A filesystem path relative to the root of the project's source code
that should be added to `sys.path` so that `astropy_helpers` can be
imported from that path.
If the path is a git submodule it will automatically be initialized
and/or updated.
The path may also be to a ``.tar.gz`` archive of the astropy_helpers
source distribution. In this case the archive is automatically
unpacked and made temporarily available on `sys.path` as a ``.egg``
archive.
If `None` skip straight to downloading.
download_if_needed : bool, optional
If the provided filesystem path is not found an attempt will be made to
download astropy_helpers from PyPI. It will then be made temporarily
available on `sys.path` as a ``.egg`` archive (using the
``setup_requires`` feature of setuptools. If the ``--offline`` option
is given at the command line the value of this argument is overridden
to `False`.
index_url : str, optional
If provided, use a different URL for the Python package index than the
main PyPI server.
use_git : bool, optional
If `False` no git commands will be used--this effectively disables
support for git submodules. If the ``--no-git`` option is given at the
command line the value of this argument is overridden to `False`.
auto_upgrade : bool, optional
By default, when installing a package from a non-development source
distribution ah_boostrap will try to automatically check for patch
releases to astropy-helpers on PyPI and use the patched version over
any bundled versions. Setting this to `False` will disable that
functionality. If the ``--offline`` option is given at the command line
the value of this argument is overridden to `False`.
offline : bool, optional
If `False` disable all actions that require an internet connection,
including downloading packages from the package index and fetching
updates to any git submodule. Defaults to `True`.
"""
global BOOTSTRAPPER
config = BOOTSTRAPPER.config
config.update(**kwargs)
# Create a new bootstrapper with the updated configuration and run it
BOOTSTRAPPER = _Bootstrapper(**config)
BOOTSTRAPPER.run() | python | def use_astropy_helpers(**kwargs):
"""
Ensure that the `astropy_helpers` module is available and is importable.
This supports automatic submodule initialization if astropy_helpers is
included in a project as a git submodule, or will download it from PyPI if
necessary.
Parameters
----------
path : str or None, optional
A filesystem path relative to the root of the project's source code
that should be added to `sys.path` so that `astropy_helpers` can be
imported from that path.
If the path is a git submodule it will automatically be initialized
and/or updated.
The path may also be to a ``.tar.gz`` archive of the astropy_helpers
source distribution. In this case the archive is automatically
unpacked and made temporarily available on `sys.path` as a ``.egg``
archive.
If `None` skip straight to downloading.
download_if_needed : bool, optional
If the provided filesystem path is not found an attempt will be made to
download astropy_helpers from PyPI. It will then be made temporarily
available on `sys.path` as a ``.egg`` archive (using the
``setup_requires`` feature of setuptools. If the ``--offline`` option
is given at the command line the value of this argument is overridden
to `False`.
index_url : str, optional
If provided, use a different URL for the Python package index than the
main PyPI server.
use_git : bool, optional
If `False` no git commands will be used--this effectively disables
support for git submodules. If the ``--no-git`` option is given at the
command line the value of this argument is overridden to `False`.
auto_upgrade : bool, optional
By default, when installing a package from a non-development source
distribution ah_boostrap will try to automatically check for patch
releases to astropy-helpers on PyPI and use the patched version over
any bundled versions. Setting this to `False` will disable that
functionality. If the ``--offline`` option is given at the command line
the value of this argument is overridden to `False`.
offline : bool, optional
If `False` disable all actions that require an internet connection,
including downloading packages from the package index and fetching
updates to any git submodule. Defaults to `True`.
"""
global BOOTSTRAPPER
config = BOOTSTRAPPER.config
config.update(**kwargs)
# Create a new bootstrapper with the updated configuration and run it
BOOTSTRAPPER = _Bootstrapper(**config)
BOOTSTRAPPER.run() | [
"def",
"use_astropy_helpers",
"(",
"**",
"kwargs",
")",
":",
"global",
"BOOTSTRAPPER",
"config",
"=",
"BOOTSTRAPPER",
".",
"config",
"config",
".",
"update",
"(",
"**",
"kwargs",
")",
"BOOTSTRAPPER",
"=",
"_Bootstrapper",
"(",
"**",
"config",
")",
"BOOTSTRAPPE... | Ensure that the `astropy_helpers` module is available and is importable.
This supports automatic submodule initialization if astropy_helpers is
included in a project as a git submodule, or will download it from PyPI if
necessary.
Parameters
----------
path : str or None, optional
A filesystem path relative to the root of the project's source code
that should be added to `sys.path` so that `astropy_helpers` can be
imported from that path.
If the path is a git submodule it will automatically be initialized
and/or updated.
The path may also be to a ``.tar.gz`` archive of the astropy_helpers
source distribution. In this case the archive is automatically
unpacked and made temporarily available on `sys.path` as a ``.egg``
archive.
If `None` skip straight to downloading.
download_if_needed : bool, optional
If the provided filesystem path is not found an attempt will be made to
download astropy_helpers from PyPI. It will then be made temporarily
available on `sys.path` as a ``.egg`` archive (using the
``setup_requires`` feature of setuptools. If the ``--offline`` option
is given at the command line the value of this argument is overridden
to `False`.
index_url : str, optional
If provided, use a different URL for the Python package index than the
main PyPI server.
use_git : bool, optional
If `False` no git commands will be used--this effectively disables
support for git submodules. If the ``--no-git`` option is given at the
command line the value of this argument is overridden to `False`.
auto_upgrade : bool, optional
By default, when installing a package from a non-development source
distribution ah_boostrap will try to automatically check for patch
releases to astropy-helpers on PyPI and use the patched version over
any bundled versions. Setting this to `False` will disable that
functionality. If the ``--offline`` option is given at the command line
the value of this argument is overridden to `False`.
offline : bool, optional
If `False` disable all actions that require an internet connection,
including downloading packages from the package index and fetching
updates to any git submodule. Defaults to `True`. | [
"Ensure",
"that",
"the",
"astropy_helpers",
"module",
"is",
"available",
"and",
"is",
"importable",
".",
"This",
"supports",
"automatic",
"submodule",
"initialization",
"if",
"astropy_helpers",
"is",
"included",
"in",
"a",
"project",
"as",
"a",
"git",
"submodule",... | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/ah_bootstrap.py#L959-L1022 | train |
astropy/regions | ah_bootstrap.py | _Bootstrapper.config | def config(self):
"""
A `dict` containing the options this `_Bootstrapper` was configured
with.
"""
return dict((optname, getattr(self, optname))
for optname, _ in CFG_OPTIONS if hasattr(self, optname)) | python | def config(self):
"""
A `dict` containing the options this `_Bootstrapper` was configured
with.
"""
return dict((optname, getattr(self, optname))
for optname, _ in CFG_OPTIONS if hasattr(self, optname)) | [
"def",
"config",
"(",
"self",
")",
":",
"return",
"dict",
"(",
"(",
"optname",
",",
"getattr",
"(",
"self",
",",
"optname",
")",
")",
"for",
"optname",
",",
"_",
"in",
"CFG_OPTIONS",
"if",
"hasattr",
"(",
"self",
",",
"optname",
")",
")"
] | A `dict` containing the options this `_Bootstrapper` was configured
with. | [
"A",
"dict",
"containing",
"the",
"options",
"this",
"_Bootstrapper",
"was",
"configured",
"with",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/ah_bootstrap.py#L393-L400 | train |
astropy/regions | ah_bootstrap.py | _Bootstrapper.get_local_directory_dist | def get_local_directory_dist(self):
"""
Handle importing a vendored package from a subdirectory of the source
distribution.
"""
if not os.path.isdir(self.path):
return
log.info('Attempting to import astropy_helpers from {0} {1!r}'.format(
'submodule' if self.is_submodule else 'directory',
self.path))
dist = self._directory_import()
if dist is None:
log.warn(
'The requested path {0!r} for importing {1} does not '
'exist, or does not contain a copy of the {1} '
'package.'.format(self.path, PACKAGE_NAME))
elif self.auto_upgrade and not self.is_submodule:
# A version of astropy-helpers was found on the available path, but
# check to see if a bugfix release is available on PyPI
upgrade = self._do_upgrade(dist)
if upgrade is not None:
dist = upgrade
return dist | python | def get_local_directory_dist(self):
"""
Handle importing a vendored package from a subdirectory of the source
distribution.
"""
if not os.path.isdir(self.path):
return
log.info('Attempting to import astropy_helpers from {0} {1!r}'.format(
'submodule' if self.is_submodule else 'directory',
self.path))
dist = self._directory_import()
if dist is None:
log.warn(
'The requested path {0!r} for importing {1} does not '
'exist, or does not contain a copy of the {1} '
'package.'.format(self.path, PACKAGE_NAME))
elif self.auto_upgrade and not self.is_submodule:
# A version of astropy-helpers was found on the available path, but
# check to see if a bugfix release is available on PyPI
upgrade = self._do_upgrade(dist)
if upgrade is not None:
dist = upgrade
return dist | [
"def",
"get_local_directory_dist",
"(",
"self",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"self",
".",
"path",
")",
":",
"return",
"log",
".",
"info",
"(",
"'Attempting to import astropy_helpers from {0} {1!r}'",
".",
"format",
"(",
"'submod... | Handle importing a vendored package from a subdirectory of the source
distribution. | [
"Handle",
"importing",
"a",
"vendored",
"package",
"from",
"a",
"subdirectory",
"of",
"the",
"source",
"distribution",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/ah_bootstrap.py#L402-L429 | train |
astropy/regions | ah_bootstrap.py | _Bootstrapper.get_local_file_dist | def get_local_file_dist(self):
"""
Handle importing from a source archive; this also uses setup_requires
but points easy_install directly to the source archive.
"""
if not os.path.isfile(self.path):
return
log.info('Attempting to unpack and import astropy_helpers from '
'{0!r}'.format(self.path))
try:
dist = self._do_download(find_links=[self.path])
except Exception as e:
if DEBUG:
raise
log.warn(
'Failed to import {0} from the specified archive {1!r}: '
'{2}'.format(PACKAGE_NAME, self.path, str(e)))
dist = None
if dist is not None and self.auto_upgrade:
# A version of astropy-helpers was found on the available path, but
# check to see if a bugfix release is available on PyPI
upgrade = self._do_upgrade(dist)
if upgrade is not None:
dist = upgrade
return dist | python | def get_local_file_dist(self):
"""
Handle importing from a source archive; this also uses setup_requires
but points easy_install directly to the source archive.
"""
if not os.path.isfile(self.path):
return
log.info('Attempting to unpack and import astropy_helpers from '
'{0!r}'.format(self.path))
try:
dist = self._do_download(find_links=[self.path])
except Exception as e:
if DEBUG:
raise
log.warn(
'Failed to import {0} from the specified archive {1!r}: '
'{2}'.format(PACKAGE_NAME, self.path, str(e)))
dist = None
if dist is not None and self.auto_upgrade:
# A version of astropy-helpers was found on the available path, but
# check to see if a bugfix release is available on PyPI
upgrade = self._do_upgrade(dist)
if upgrade is not None:
dist = upgrade
return dist | [
"def",
"get_local_file_dist",
"(",
"self",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"self",
".",
"path",
")",
":",
"return",
"log",
".",
"info",
"(",
"'Attempting to unpack and import astropy_helpers from '",
"'{0!r}'",
".",
"format",
"(",... | Handle importing from a source archive; this also uses setup_requires
but points easy_install directly to the source archive. | [
"Handle",
"importing",
"from",
"a",
"source",
"archive",
";",
"this",
"also",
"uses",
"setup_requires",
"but",
"points",
"easy_install",
"directly",
"to",
"the",
"source",
"archive",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/ah_bootstrap.py#L431-L461 | train |
astropy/regions | ah_bootstrap.py | _Bootstrapper._directory_import | def _directory_import(self):
"""
Import astropy_helpers from the given path, which will be added to
sys.path.
Must return True if the import succeeded, and False otherwise.
"""
# Return True on success, False on failure but download is allowed, and
# otherwise raise SystemExit
path = os.path.abspath(self.path)
# Use an empty WorkingSet rather than the man
# pkg_resources.working_set, since on older versions of setuptools this
# will invoke a VersionConflict when trying to install an upgrade
ws = pkg_resources.WorkingSet([])
ws.add_entry(path)
dist = ws.by_key.get(DIST_NAME)
if dist is None:
# We didn't find an egg-info/dist-info in the given path, but if a
# setup.py exists we can generate it
setup_py = os.path.join(path, 'setup.py')
if os.path.isfile(setup_py):
# We use subprocess instead of run_setup from setuptools to
# avoid segmentation faults - see the following for more details:
# https://github.com/cython/cython/issues/2104
sp.check_output([sys.executable, 'setup.py', 'egg_info'], cwd=path)
for dist in pkg_resources.find_distributions(path, True):
# There should be only one...
return dist
return dist | python | def _directory_import(self):
"""
Import astropy_helpers from the given path, which will be added to
sys.path.
Must return True if the import succeeded, and False otherwise.
"""
# Return True on success, False on failure but download is allowed, and
# otherwise raise SystemExit
path = os.path.abspath(self.path)
# Use an empty WorkingSet rather than the man
# pkg_resources.working_set, since on older versions of setuptools this
# will invoke a VersionConflict when trying to install an upgrade
ws = pkg_resources.WorkingSet([])
ws.add_entry(path)
dist = ws.by_key.get(DIST_NAME)
if dist is None:
# We didn't find an egg-info/dist-info in the given path, but if a
# setup.py exists we can generate it
setup_py = os.path.join(path, 'setup.py')
if os.path.isfile(setup_py):
# We use subprocess instead of run_setup from setuptools to
# avoid segmentation faults - see the following for more details:
# https://github.com/cython/cython/issues/2104
sp.check_output([sys.executable, 'setup.py', 'egg_info'], cwd=path)
for dist in pkg_resources.find_distributions(path, True):
# There should be only one...
return dist
return dist | [
"def",
"_directory_import",
"(",
"self",
")",
":",
"path",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"self",
".",
"path",
")",
"ws",
"=",
"pkg_resources",
".",
"WorkingSet",
"(",
"[",
"]",
")",
"ws",
".",
"add_entry",
"(",
"path",
")",
"dist",
"... | Import astropy_helpers from the given path, which will be added to
sys.path.
Must return True if the import succeeded, and False otherwise. | [
"Import",
"astropy_helpers",
"from",
"the",
"given",
"path",
"which",
"will",
"be",
"added",
"to",
"sys",
".",
"path",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/ah_bootstrap.py#L486-L519 | train |
astropy/regions | ah_bootstrap.py | _Bootstrapper._check_submodule | def _check_submodule(self):
"""
Check if the given path is a git submodule.
See the docstrings for ``_check_submodule_using_git`` and
``_check_submodule_no_git`` for further details.
"""
if (self.path is None or
(os.path.exists(self.path) and not os.path.isdir(self.path))):
return False
if self.use_git:
return self._check_submodule_using_git()
else:
return self._check_submodule_no_git() | python | def _check_submodule(self):
"""
Check if the given path is a git submodule.
See the docstrings for ``_check_submodule_using_git`` and
``_check_submodule_no_git`` for further details.
"""
if (self.path is None or
(os.path.exists(self.path) and not os.path.isdir(self.path))):
return False
if self.use_git:
return self._check_submodule_using_git()
else:
return self._check_submodule_no_git() | [
"def",
"_check_submodule",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"path",
"is",
"None",
"or",
"(",
"os",
".",
"path",
".",
"exists",
"(",
"self",
".",
"path",
")",
"and",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"self",
".",
"path",
... | Check if the given path is a git submodule.
See the docstrings for ``_check_submodule_using_git`` and
``_check_submodule_no_git`` for further details. | [
"Check",
"if",
"the",
"given",
"path",
"is",
"a",
"git",
"submodule",
"."
] | 452d962c417e4ff20d1268f99535c6ff89c83437 | https://github.com/astropy/regions/blob/452d962c417e4ff20d1268f99535c6ff89c83437/ah_bootstrap.py#L607-L622 | train |
EconForge/dolo | dolo/numeric/tensor.py | sdot | def sdot( U, V ):
'''
Computes the tensorproduct reducing last dimensoin of U with first dimension of V.
For matrices, it is equal to regular matrix product.
'''
nu = U.ndim
#nv = V.ndim
return np.tensordot( U, V, axes=(nu-1,0) ) | python | def sdot( U, V ):
'''
Computes the tensorproduct reducing last dimensoin of U with first dimension of V.
For matrices, it is equal to regular matrix product.
'''
nu = U.ndim
#nv = V.ndim
return np.tensordot( U, V, axes=(nu-1,0) ) | [
"def",
"sdot",
"(",
"U",
",",
"V",
")",
":",
"nu",
"=",
"U",
".",
"ndim",
"return",
"np",
".",
"tensordot",
"(",
"U",
",",
"V",
",",
"axes",
"=",
"(",
"nu",
"-",
"1",
",",
"0",
")",
")"
] | Computes the tensorproduct reducing last dimensoin of U with first dimension of V.
For matrices, it is equal to regular matrix product. | [
"Computes",
"the",
"tensorproduct",
"reducing",
"last",
"dimensoin",
"of",
"U",
"with",
"first",
"dimension",
"of",
"V",
".",
"For",
"matrices",
"it",
"is",
"equal",
"to",
"regular",
"matrix",
"product",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/tensor.py#L44-L51 | train |
EconForge/dolo | dolo/numeric/interpolation/smolyak.py | SmolyakBasic.set_values | def set_values(self,x):
""" Updates self.theta parameter. No returns values"""
x = numpy.atleast_2d(x)
x = x.real # ahem
C_inv = self.__C_inv__
theta = numpy.dot( x, C_inv )
self.theta = theta
return theta | python | def set_values(self,x):
""" Updates self.theta parameter. No returns values"""
x = numpy.atleast_2d(x)
x = x.real # ahem
C_inv = self.__C_inv__
theta = numpy.dot( x, C_inv )
self.theta = theta
return theta | [
"def",
"set_values",
"(",
"self",
",",
"x",
")",
":",
"x",
"=",
"numpy",
".",
"atleast_2d",
"(",
"x",
")",
"x",
"=",
"x",
".",
"real",
"C_inv",
"=",
"self",
".",
"__C_inv__",
"theta",
"=",
"numpy",
".",
"dot",
"(",
"x",
",",
"C_inv",
")",
"self... | Updates self.theta parameter. No returns values | [
"Updates",
"self",
".",
"theta",
"parameter",
".",
"No",
"returns",
"values"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/interpolation/smolyak.py#L256-L267 | train |
EconForge/dolo | dolo/numeric/discretization/discretization.py | tauchen | def tauchen(N, mu, rho, sigma, m=2):
"""
Approximate an AR1 process by a finite markov chain using Tauchen's method.
:param N: scalar, number of nodes for Z
:param mu: scalar, unconditional mean of process
:param rho: scalar
:param sigma: scalar, std. dev. of epsilons
:param m: max +- std. devs.
:returns: Z, N*1 vector, nodes for Z. Zprob, N*N matrix, transition probabilities
SJB: This is a port of Martin Floden's 1996 Matlab code to implement Tauchen 1986 Economic Letters method The following comments are Floden's. Finds a Markov chain whose sample paths approximate those of the AR(1) process z(t+1) = (1-rho)*mu + rho * z(t) + eps(t+1) where eps are normal with stddev sigma.
"""
Z = np.zeros((N,1))
Zprob = np.zeros((N,N))
a = (1-rho)*mu
Z[-1] = m * math.sqrt(sigma**2 / (1 - (rho**2)))
Z[0] = -1 * Z[-1]
zstep = (Z[-1] - Z[0]) / (N - 1)
for i in range(1,N):
Z[i] = Z[0] + zstep * (i)
Z = Z + a / (1-rho)
for j in range(0,N):
for k in range(0,N):
if k == 0:
Zprob[j,k] = sp.stats.norm.cdf((Z[0] - a - rho * Z[j] + zstep / 2) / sigma)
elif k == (N-1):
Zprob[j,k] = 1 - sp.stats.norm.cdf((Z[-1] - a - rho * Z[j] - zstep / 2) / sigma)
else:
up = sp.stats.norm.cdf((Z[k] - a - rho * Z[j] + zstep / 2) / sigma)
down = sp.stats.norm.cdf( (Z[k] - a - rho * Z[j] - zstep / 2) / sigma)
Zprob[j,k] = up - down
return( (Z, Zprob) ) | python | def tauchen(N, mu, rho, sigma, m=2):
"""
Approximate an AR1 process by a finite markov chain using Tauchen's method.
:param N: scalar, number of nodes for Z
:param mu: scalar, unconditional mean of process
:param rho: scalar
:param sigma: scalar, std. dev. of epsilons
:param m: max +- std. devs.
:returns: Z, N*1 vector, nodes for Z. Zprob, N*N matrix, transition probabilities
SJB: This is a port of Martin Floden's 1996 Matlab code to implement Tauchen 1986 Economic Letters method The following comments are Floden's. Finds a Markov chain whose sample paths approximate those of the AR(1) process z(t+1) = (1-rho)*mu + rho * z(t) + eps(t+1) where eps are normal with stddev sigma.
"""
Z = np.zeros((N,1))
Zprob = np.zeros((N,N))
a = (1-rho)*mu
Z[-1] = m * math.sqrt(sigma**2 / (1 - (rho**2)))
Z[0] = -1 * Z[-1]
zstep = (Z[-1] - Z[0]) / (N - 1)
for i in range(1,N):
Z[i] = Z[0] + zstep * (i)
Z = Z + a / (1-rho)
for j in range(0,N):
for k in range(0,N):
if k == 0:
Zprob[j,k] = sp.stats.norm.cdf((Z[0] - a - rho * Z[j] + zstep / 2) / sigma)
elif k == (N-1):
Zprob[j,k] = 1 - sp.stats.norm.cdf((Z[-1] - a - rho * Z[j] - zstep / 2) / sigma)
else:
up = sp.stats.norm.cdf((Z[k] - a - rho * Z[j] + zstep / 2) / sigma)
down = sp.stats.norm.cdf( (Z[k] - a - rho * Z[j] - zstep / 2) / sigma)
Zprob[j,k] = up - down
return( (Z, Zprob) ) | [
"def",
"tauchen",
"(",
"N",
",",
"mu",
",",
"rho",
",",
"sigma",
",",
"m",
"=",
"2",
")",
":",
"Z",
"=",
"np",
".",
"zeros",
"(",
"(",
"N",
",",
"1",
")",
")",
"Zprob",
"=",
"np",
".",
"zeros",
"(",
"(",
"N",
",",
"N",
")",
")",
"a",
... | Approximate an AR1 process by a finite markov chain using Tauchen's method.
:param N: scalar, number of nodes for Z
:param mu: scalar, unconditional mean of process
:param rho: scalar
:param sigma: scalar, std. dev. of epsilons
:param m: max +- std. devs.
:returns: Z, N*1 vector, nodes for Z. Zprob, N*N matrix, transition probabilities
SJB: This is a port of Martin Floden's 1996 Matlab code to implement Tauchen 1986 Economic Letters method The following comments are Floden's. Finds a Markov chain whose sample paths approximate those of the AR(1) process z(t+1) = (1-rho)*mu + rho * z(t) + eps(t+1) where eps are normal with stddev sigma. | [
"Approximate",
"an",
"AR1",
"process",
"by",
"a",
"finite",
"markov",
"chain",
"using",
"Tauchen",
"s",
"method",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/discretization/discretization.py#L13-L50 | train |
EconForge/dolo | dolo/numeric/discretization/discretization.py | rouwenhorst | def rouwenhorst(rho, sigma, N):
"""
Approximate an AR1 process by a finite markov chain using Rouwenhorst's method.
:param rho: autocorrelation of the AR1 process
:param sigma: conditional standard deviation of the AR1 process
:param N: number of states
:return [nodes, P]: equally spaced nodes and transition matrix
"""
from numpy import sqrt, linspace, array,zeros
sigma = float(sigma)
if N == 1:
nodes = array([0.0])
transitions = array([[1.0]])
return [nodes, transitions]
p = (rho+1)/2
q = p
nu = sqrt( (N-1)/(1-rho**2) )*sigma
nodes = linspace( -nu, nu, N)
sig_a = sigma
n = 1
# mat0 = array( [[1]] )
mat0 = array([[p,1-p],[1-q,q]])
if N == 2:
return [nodes,mat0]
for n in range(3,N+1):
mat = zeros( (n,n) )
mat_A = mat.copy()
mat_B = mat.copy()
mat_C = mat.copy()
mat_D = mat.copy()
mat_A[:-1,:-1] = mat0
mat_B[:-1,1:] = mat0
mat_C[1:,:-1] = mat0
mat_D[1:,1:] = mat0
mat0 = p*mat_A + (1-p)*mat_B + (1-q)*mat_C + q*mat_D
mat0[1:-1,:] = mat0[1:-1,:]/2
P = mat0
return [nodes, P] | python | def rouwenhorst(rho, sigma, N):
"""
Approximate an AR1 process by a finite markov chain using Rouwenhorst's method.
:param rho: autocorrelation of the AR1 process
:param sigma: conditional standard deviation of the AR1 process
:param N: number of states
:return [nodes, P]: equally spaced nodes and transition matrix
"""
from numpy import sqrt, linspace, array,zeros
sigma = float(sigma)
if N == 1:
nodes = array([0.0])
transitions = array([[1.0]])
return [nodes, transitions]
p = (rho+1)/2
q = p
nu = sqrt( (N-1)/(1-rho**2) )*sigma
nodes = linspace( -nu, nu, N)
sig_a = sigma
n = 1
# mat0 = array( [[1]] )
mat0 = array([[p,1-p],[1-q,q]])
if N == 2:
return [nodes,mat0]
for n in range(3,N+1):
mat = zeros( (n,n) )
mat_A = mat.copy()
mat_B = mat.copy()
mat_C = mat.copy()
mat_D = mat.copy()
mat_A[:-1,:-1] = mat0
mat_B[:-1,1:] = mat0
mat_C[1:,:-1] = mat0
mat_D[1:,1:] = mat0
mat0 = p*mat_A + (1-p)*mat_B + (1-q)*mat_C + q*mat_D
mat0[1:-1,:] = mat0[1:-1,:]/2
P = mat0
return [nodes, P] | [
"def",
"rouwenhorst",
"(",
"rho",
",",
"sigma",
",",
"N",
")",
":",
"from",
"numpy",
"import",
"sqrt",
",",
"linspace",
",",
"array",
",",
"zeros",
"sigma",
"=",
"float",
"(",
"sigma",
")",
"if",
"N",
"==",
"1",
":",
"nodes",
"=",
"array",
"(",
"... | Approximate an AR1 process by a finite markov chain using Rouwenhorst's method.
:param rho: autocorrelation of the AR1 process
:param sigma: conditional standard deviation of the AR1 process
:param N: number of states
:return [nodes, P]: equally spaced nodes and transition matrix | [
"Approximate",
"an",
"AR1",
"process",
"by",
"a",
"finite",
"markov",
"chain",
"using",
"Rouwenhorst",
"s",
"method",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/discretization/discretization.py#L53-L97 | train |
EconForge/dolo | dolo/numeric/discretization/discretization.py | tensor_markov | def tensor_markov( *args ):
"""Computes the product of two independent markov chains.
:param m1: a tuple containing the nodes and the transition matrix of the first chain
:param m2: a tuple containing the nodes and the transition matrix of the second chain
:return: a tuple containing the nodes and the transition matrix of the product chain
"""
if len(args) > 2:
m1 = args[0]
m2 = args[1]
tail = args[2:]
prod = tensor_markov(m1,m2)
return tensor_markov( prod, tail )
elif len(args) == 2:
m1,m2 = args
n1, t1 = m1
n2, t2 = m2
n1 = np.array(n1, dtype=float)
n2 = np.array(n2, dtype=float)
t1 = np.array(t1, dtype=float)
t2 = np.array(t2, dtype=float)
assert(n1.shape[0] == t1.shape[0] == t1.shape[1])
assert(n2.shape[0] == t2.shape[0] == t2.shape[1])
t = np.kron(t1, t2)
p = t1.shape[0]
q = t2.shape[0]
np.tile( n2, (1,p))
# n = np.row_stack([
# np.repeat(n1, q, axis=1),
# np.tile( n2, (1,p))
# ])
n = np.column_stack([
np.repeat(n1, q, axis=0),
np.tile( n2, (p,1))
])
return [n,t]
else:
raise Exception("Incorrect number of arguments. Expected at least 2. Found {}.".format(len(args))) | python | def tensor_markov( *args ):
"""Computes the product of two independent markov chains.
:param m1: a tuple containing the nodes and the transition matrix of the first chain
:param m2: a tuple containing the nodes and the transition matrix of the second chain
:return: a tuple containing the nodes and the transition matrix of the product chain
"""
if len(args) > 2:
m1 = args[0]
m2 = args[1]
tail = args[2:]
prod = tensor_markov(m1,m2)
return tensor_markov( prod, tail )
elif len(args) == 2:
m1,m2 = args
n1, t1 = m1
n2, t2 = m2
n1 = np.array(n1, dtype=float)
n2 = np.array(n2, dtype=float)
t1 = np.array(t1, dtype=float)
t2 = np.array(t2, dtype=float)
assert(n1.shape[0] == t1.shape[0] == t1.shape[1])
assert(n2.shape[0] == t2.shape[0] == t2.shape[1])
t = np.kron(t1, t2)
p = t1.shape[0]
q = t2.shape[0]
np.tile( n2, (1,p))
# n = np.row_stack([
# np.repeat(n1, q, axis=1),
# np.tile( n2, (1,p))
# ])
n = np.column_stack([
np.repeat(n1, q, axis=0),
np.tile( n2, (p,1))
])
return [n,t]
else:
raise Exception("Incorrect number of arguments. Expected at least 2. Found {}.".format(len(args))) | [
"def",
"tensor_markov",
"(",
"*",
"args",
")",
":",
"if",
"len",
"(",
"args",
")",
">",
"2",
":",
"m1",
"=",
"args",
"[",
"0",
"]",
"m2",
"=",
"args",
"[",
"1",
"]",
"tail",
"=",
"args",
"[",
"2",
":",
"]",
"prod",
"=",
"tensor_markov",
"(",
... | Computes the product of two independent markov chains.
:param m1: a tuple containing the nodes and the transition matrix of the first chain
:param m2: a tuple containing the nodes and the transition matrix of the second chain
:return: a tuple containing the nodes and the transition matrix of the product chain | [
"Computes",
"the",
"product",
"of",
"two",
"independent",
"markov",
"chains",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/discretization/discretization.py#L155-L201 | train |
EconForge/dolo | trash/dolo/misc/modfile.py | dynare_import | def dynare_import(filename,full_output=False, debug=False):
'''Imports model defined in specified file'''
import os
basename = os.path.basename(filename)
fname = re.compile('(.*)\.(.*)').match(basename).group(1)
f = open(filename)
txt = f.read()
model = parse_dynare_text(txt,full_output=full_output, debug=debug)
model.name = fname
return model | python | def dynare_import(filename,full_output=False, debug=False):
'''Imports model defined in specified file'''
import os
basename = os.path.basename(filename)
fname = re.compile('(.*)\.(.*)').match(basename).group(1)
f = open(filename)
txt = f.read()
model = parse_dynare_text(txt,full_output=full_output, debug=debug)
model.name = fname
return model | [
"def",
"dynare_import",
"(",
"filename",
",",
"full_output",
"=",
"False",
",",
"debug",
"=",
"False",
")",
":",
"import",
"os",
"basename",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"filename",
")",
"fname",
"=",
"re",
".",
"compile",
"(",
"'(.*)\... | Imports model defined in specified file | [
"Imports",
"model",
"defined",
"in",
"specified",
"file"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/trash/dolo/misc/modfile.py#L311-L320 | train |
EconForge/dolo | dolo/algos/perfect_foresight.py | _shocks_to_epsilons | def _shocks_to_epsilons(model, shocks, T):
"""
Helper function to support input argument `shocks` being one of many
different data types. Will always return a `T, n_e` matrix.
"""
n_e = len(model.calibration['exogenous'])
# if we have a DataFrame, convert it to a dict and rely on the method below
if isinstance(shocks, pd.DataFrame):
shocks = {k: shocks[k].tolist() for k in shocks.columns}
# handle case where shocks might be a dict. Be careful to handle case where
# value arrays are not the same length
if isinstance(shocks, dict):
epsilons = np.zeros((T + 1, n_e))
for (i, k) in enumerate(model.symbols["exogenous"]):
if k in shocks:
this_shock = shocks[k]
epsilons[:len(this_shock), i] = this_shock
epsilons[len(this_shock):, i] = this_shock[-1]
else:
# otherwise set to value in calibration
epsilons[:, i] = model.calibration["exogenous"][i]
return epsilons
# read from calibration if not given
if shocks is None:
shocks = model.calibration["exogenous"]
# now we just assume that shocks is array-like and try using the output of
# np.asarray(shocks)
shocks = np.asarray(shocks)
shocks = shocks.reshape((-1, n_e))
# until last period, exogenous shock takes its last value
epsilons = np.zeros((T + 1, n_e))
epsilons[:(shocks.shape[0] - 1), :] = shocks[1:, :]
epsilons[(shocks.shape[0] - 1):, :] = shocks[-1:, :]
return epsilons | python | def _shocks_to_epsilons(model, shocks, T):
"""
Helper function to support input argument `shocks` being one of many
different data types. Will always return a `T, n_e` matrix.
"""
n_e = len(model.calibration['exogenous'])
# if we have a DataFrame, convert it to a dict and rely on the method below
if isinstance(shocks, pd.DataFrame):
shocks = {k: shocks[k].tolist() for k in shocks.columns}
# handle case where shocks might be a dict. Be careful to handle case where
# value arrays are not the same length
if isinstance(shocks, dict):
epsilons = np.zeros((T + 1, n_e))
for (i, k) in enumerate(model.symbols["exogenous"]):
if k in shocks:
this_shock = shocks[k]
epsilons[:len(this_shock), i] = this_shock
epsilons[len(this_shock):, i] = this_shock[-1]
else:
# otherwise set to value in calibration
epsilons[:, i] = model.calibration["exogenous"][i]
return epsilons
# read from calibration if not given
if shocks is None:
shocks = model.calibration["exogenous"]
# now we just assume that shocks is array-like and try using the output of
# np.asarray(shocks)
shocks = np.asarray(shocks)
shocks = shocks.reshape((-1, n_e))
# until last period, exogenous shock takes its last value
epsilons = np.zeros((T + 1, n_e))
epsilons[:(shocks.shape[0] - 1), :] = shocks[1:, :]
epsilons[(shocks.shape[0] - 1):, :] = shocks[-1:, :]
return epsilons | [
"def",
"_shocks_to_epsilons",
"(",
"model",
",",
"shocks",
",",
"T",
")",
":",
"n_e",
"=",
"len",
"(",
"model",
".",
"calibration",
"[",
"'exogenous'",
"]",
")",
"if",
"isinstance",
"(",
"shocks",
",",
"pd",
".",
"DataFrame",
")",
":",
"shocks",
"=",
... | Helper function to support input argument `shocks` being one of many
different data types. Will always return a `T, n_e` matrix. | [
"Helper",
"function",
"to",
"support",
"input",
"argument",
"shocks",
"being",
"one",
"of",
"many",
"different",
"data",
"types",
".",
"Will",
"always",
"return",
"a",
"T",
"n_e",
"matrix",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/algos/perfect_foresight.py#L9-L49 | train |
EconForge/dolo | trash/dolo/misc/symbolic_interactive.py | clear_all | def clear_all():
"""
Clears all parameters, variables, and shocks defined previously
"""
frame = inspect.currentframe().f_back
try:
if frame.f_globals.get('variables_order'):
# we should avoid to declare symbols twice !
del frame.f_globals['variables_order']
if frame.f_globals.get('parameters_order'):
# we should avoid to declare symbols twice !
del frame.f_globals['parameters_order']
finally:
del frame | python | def clear_all():
"""
Clears all parameters, variables, and shocks defined previously
"""
frame = inspect.currentframe().f_back
try:
if frame.f_globals.get('variables_order'):
# we should avoid to declare symbols twice !
del frame.f_globals['variables_order']
if frame.f_globals.get('parameters_order'):
# we should avoid to declare symbols twice !
del frame.f_globals['parameters_order']
finally:
del frame | [
"def",
"clear_all",
"(",
")",
":",
"frame",
"=",
"inspect",
".",
"currentframe",
"(",
")",
".",
"f_back",
"try",
":",
"if",
"frame",
".",
"f_globals",
".",
"get",
"(",
"'variables_order'",
")",
":",
"del",
"frame",
".",
"f_globals",
"[",
"'variables_orde... | Clears all parameters, variables, and shocks defined previously | [
"Clears",
"all",
"parameters",
"variables",
"and",
"shocks",
"defined",
"previously"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/trash/dolo/misc/symbolic_interactive.py#L319-L333 | train |
EconForge/dolo | trash/dolo/algos/dtcscc/nonlinearsystem.py | nonlinear_system | def nonlinear_system(model, initial_dr=None, maxit=10, tol=1e-8, grid={}, distribution={}, verbose=True):
'''
Finds a global solution for ``model`` by solving one large system of equations
using a simple newton algorithm.
Parameters
----------
model: NumericModel
"dtcscc" model to be solved
verbose: boolean
if True, display iterations
initial_dr: decision rule
initial guess for the decision rule
maxit: int
maximum number of iterationsd
tol: tolerance criterium for successive approximations
grid: grid options
distribution: distribution options
Returns
-------
decision rule :
approximated solution
'''
if verbose:
headline = '|{0:^4} | {1:10} | {2:8} |'
headline = headline.format('N', ' Error', 'Time')
stars = '-'*len(headline)
print(stars)
print(headline)
print(stars)
# format string for within loop
fmt_str = '|{0:4} | {1:10.3e} | {2:8.3f} |'
f = model.functions['arbitrage']
g = model.functions['transition']
p = model.calibration['parameters']
distrib = model.get_distribution(**distribution)
nodes, weights = distrib.discretize()
approx = model.get_grid(**grid)
ms = create_interpolator(approx, approx.interpolation)
grid = ms.grid
if initial_dr is None:
dr = approximate_controls(model)
else:
dr = initial_dr
ms.set_values(dr(grid))
x = dr(grid)
x0 = x.copy()
it = 0
err = 10
a0 = x0.copy().reshape((x0.shape[0]*x0.shape[1],))
a = a0.copy()
while err > tol and it < maxit:
it += 1
t1 = time.time()
r, da = residuals(f, g, grid, a.reshape(x0.shape), ms, nodes, weights, p, diff=True)[:2]
r = r.flatten()
err = abs(r).max()
t2 = time.time()
if verbose:
print(fmt_str.format(it, err, t2-t1))
if err > tol:
a -= scipy.sparse.linalg.spsolve(da, r)
if verbose:
print(stars)
return ms | python | def nonlinear_system(model, initial_dr=None, maxit=10, tol=1e-8, grid={}, distribution={}, verbose=True):
'''
Finds a global solution for ``model`` by solving one large system of equations
using a simple newton algorithm.
Parameters
----------
model: NumericModel
"dtcscc" model to be solved
verbose: boolean
if True, display iterations
initial_dr: decision rule
initial guess for the decision rule
maxit: int
maximum number of iterationsd
tol: tolerance criterium for successive approximations
grid: grid options
distribution: distribution options
Returns
-------
decision rule :
approximated solution
'''
if verbose:
headline = '|{0:^4} | {1:10} | {2:8} |'
headline = headline.format('N', ' Error', 'Time')
stars = '-'*len(headline)
print(stars)
print(headline)
print(stars)
# format string for within loop
fmt_str = '|{0:4} | {1:10.3e} | {2:8.3f} |'
f = model.functions['arbitrage']
g = model.functions['transition']
p = model.calibration['parameters']
distrib = model.get_distribution(**distribution)
nodes, weights = distrib.discretize()
approx = model.get_grid(**grid)
ms = create_interpolator(approx, approx.interpolation)
grid = ms.grid
if initial_dr is None:
dr = approximate_controls(model)
else:
dr = initial_dr
ms.set_values(dr(grid))
x = dr(grid)
x0 = x.copy()
it = 0
err = 10
a0 = x0.copy().reshape((x0.shape[0]*x0.shape[1],))
a = a0.copy()
while err > tol and it < maxit:
it += 1
t1 = time.time()
r, da = residuals(f, g, grid, a.reshape(x0.shape), ms, nodes, weights, p, diff=True)[:2]
r = r.flatten()
err = abs(r).max()
t2 = time.time()
if verbose:
print(fmt_str.format(it, err, t2-t1))
if err > tol:
a -= scipy.sparse.linalg.spsolve(da, r)
if verbose:
print(stars)
return ms | [
"def",
"nonlinear_system",
"(",
"model",
",",
"initial_dr",
"=",
"None",
",",
"maxit",
"=",
"10",
",",
"tol",
"=",
"1e-8",
",",
"grid",
"=",
"{",
"}",
",",
"distribution",
"=",
"{",
"}",
",",
"verbose",
"=",
"True",
")",
":",
"if",
"verbose",
":",
... | Finds a global solution for ``model`` by solving one large system of equations
using a simple newton algorithm.
Parameters
----------
model: NumericModel
"dtcscc" model to be solved
verbose: boolean
if True, display iterations
initial_dr: decision rule
initial guess for the decision rule
maxit: int
maximum number of iterationsd
tol: tolerance criterium for successive approximations
grid: grid options
distribution: distribution options
Returns
-------
decision rule :
approximated solution | [
"Finds",
"a",
"global",
"solution",
"for",
"model",
"by",
"solving",
"one",
"large",
"system",
"of",
"equations",
"using",
"a",
"simple",
"newton",
"algorithm",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/trash/dolo/algos/dtcscc/nonlinearsystem.py#L10-L97 | train |
EconForge/dolo | dolo/numeric/discretization/quadrature.py | gauss_hermite_nodes | def gauss_hermite_nodes(orders, sigma, mu=None):
'''
Computes the weights and nodes for Gauss Hermite quadrature.
Parameters
----------
orders : int, list, array
The order of integration used in the quadrature routine
sigma : array-like
If one dimensional, the variance of the normal distribution being
approximated. If multidimensional, the variance-covariance matrix of
the multivariate normal process being approximated.
Returns
-------
x : array
Quadrature nodes
w : array
Quadrature weights
'''
if isinstance(orders, int):
orders = [orders]
import numpy
if mu is None:
mu = numpy.array( [0]*sigma.shape[0] )
herms = [hermgauss(i) for i in orders]
points = [ h[0]*numpy.sqrt(2) for h in herms]
weights = [ h[1]/numpy.sqrt( numpy.pi) for h in herms]
if len(orders) == 1:
# Note: if sigma is 2D, x will always be 2D, even if sigma is only 1x1.
# print(points.shape)
x = numpy.array(points[0])*numpy.sqrt(float(sigma))
if sigma.ndim==2:
x = x[:,None]
w = weights[0]
return [x,w]
else:
x = cartesian( points).T
from functools import reduce
w = reduce( numpy.kron, weights)
zero_columns = numpy.where(sigma.sum(axis=0)==0)[0]
for i in zero_columns:
sigma[i,i] = 1.0
C = numpy.linalg.cholesky(sigma)
x = numpy.dot(C, x) + mu[:,numpy.newaxis]
x = numpy.ascontiguousarray(x.T)
for i in zero_columns:
x[:,i] =0
return [x,w] | python | def gauss_hermite_nodes(orders, sigma, mu=None):
'''
Computes the weights and nodes for Gauss Hermite quadrature.
Parameters
----------
orders : int, list, array
The order of integration used in the quadrature routine
sigma : array-like
If one dimensional, the variance of the normal distribution being
approximated. If multidimensional, the variance-covariance matrix of
the multivariate normal process being approximated.
Returns
-------
x : array
Quadrature nodes
w : array
Quadrature weights
'''
if isinstance(orders, int):
orders = [orders]
import numpy
if mu is None:
mu = numpy.array( [0]*sigma.shape[0] )
herms = [hermgauss(i) for i in orders]
points = [ h[0]*numpy.sqrt(2) for h in herms]
weights = [ h[1]/numpy.sqrt( numpy.pi) for h in herms]
if len(orders) == 1:
# Note: if sigma is 2D, x will always be 2D, even if sigma is only 1x1.
# print(points.shape)
x = numpy.array(points[0])*numpy.sqrt(float(sigma))
if sigma.ndim==2:
x = x[:,None]
w = weights[0]
return [x,w]
else:
x = cartesian( points).T
from functools import reduce
w = reduce( numpy.kron, weights)
zero_columns = numpy.where(sigma.sum(axis=0)==0)[0]
for i in zero_columns:
sigma[i,i] = 1.0
C = numpy.linalg.cholesky(sigma)
x = numpy.dot(C, x) + mu[:,numpy.newaxis]
x = numpy.ascontiguousarray(x.T)
for i in zero_columns:
x[:,i] =0
return [x,w] | [
"def",
"gauss_hermite_nodes",
"(",
"orders",
",",
"sigma",
",",
"mu",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"orders",
",",
"int",
")",
":",
"orders",
"=",
"[",
"orders",
"]",
"import",
"numpy",
"if",
"mu",
"is",
"None",
":",
"mu",
"=",
"n... | Computes the weights and nodes for Gauss Hermite quadrature.
Parameters
----------
orders : int, list, array
The order of integration used in the quadrature routine
sigma : array-like
If one dimensional, the variance of the normal distribution being
approximated. If multidimensional, the variance-covariance matrix of
the multivariate normal process being approximated.
Returns
-------
x : array
Quadrature nodes
w : array
Quadrature weights | [
"Computes",
"the",
"weights",
"and",
"nodes",
"for",
"Gauss",
"Hermite",
"quadrature",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/discretization/quadrature.py#L59-L122 | train |
EconForge/dolo | dolo/numeric/optimize/newton.py | newton | def newton(f, x, verbose=False, tol=1e-6, maxit=5, jactype='serial'):
"""Solve nonlinear system using safeguarded Newton iterations
Parameters
----------
Return
------
"""
if verbose:
print = lambda txt: old_print(txt)
else:
print = lambda txt: None
it = 0
error = 10
converged = False
maxbacksteps = 30
x0 = x
if jactype == 'sparse':
from scipy.sparse.linalg import spsolve as solve
elif jactype == 'full':
from numpy.linalg import solve
else:
solve = serial_solve
while it<maxit and not converged:
[v,dv] = f(x)
# TODO: rewrite starting here
# print("Time to evaluate {}".format(ss-tt)0)
error_0 = abs(v).max()
if error_0 < tol:
if verbose:
print("> System was solved after iteration {}. Residual={}".format(it,error_0))
converged = True
else:
it += 1
dx = solve(dv, v)
# norm_dx = abs(dx).max()
for bck in range(maxbacksteps):
xx = x - dx*(2**(-bck))
vm = f(xx)[0]
err = abs(vm).max()
if err < error_0:
break
x = xx
if verbose:
print("\t> {} | {} | {}".format(it, err, bck))
if not converged:
import warnings
warnings.warn("Did not converge")
return [x, it] | python | def newton(f, x, verbose=False, tol=1e-6, maxit=5, jactype='serial'):
"""Solve nonlinear system using safeguarded Newton iterations
Parameters
----------
Return
------
"""
if verbose:
print = lambda txt: old_print(txt)
else:
print = lambda txt: None
it = 0
error = 10
converged = False
maxbacksteps = 30
x0 = x
if jactype == 'sparse':
from scipy.sparse.linalg import spsolve as solve
elif jactype == 'full':
from numpy.linalg import solve
else:
solve = serial_solve
while it<maxit and not converged:
[v,dv] = f(x)
# TODO: rewrite starting here
# print("Time to evaluate {}".format(ss-tt)0)
error_0 = abs(v).max()
if error_0 < tol:
if verbose:
print("> System was solved after iteration {}. Residual={}".format(it,error_0))
converged = True
else:
it += 1
dx = solve(dv, v)
# norm_dx = abs(dx).max()
for bck in range(maxbacksteps):
xx = x - dx*(2**(-bck))
vm = f(xx)[0]
err = abs(vm).max()
if err < error_0:
break
x = xx
if verbose:
print("\t> {} | {} | {}".format(it, err, bck))
if not converged:
import warnings
warnings.warn("Did not converge")
return [x, it] | [
"def",
"newton",
"(",
"f",
",",
"x",
",",
"verbose",
"=",
"False",
",",
"tol",
"=",
"1e-6",
",",
"maxit",
"=",
"5",
",",
"jactype",
"=",
"'serial'",
")",
":",
"if",
"verbose",
":",
"print",
"=",
"lambda",
"txt",
":",
"old_print",
"(",
"txt",
")",... | Solve nonlinear system using safeguarded Newton iterations
Parameters
----------
Return
------ | [
"Solve",
"nonlinear",
"system",
"using",
"safeguarded",
"Newton",
"iterations"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/optimize/newton.py#L81-L151 | train |
EconForge/dolo | dolo/numeric/extern/qz.py | qzordered | def qzordered(A,B,crit=1.0):
"Eigenvalues bigger than crit are sorted in the top-left."
TOL = 1e-10
def select(alpha, beta):
return alpha**2>crit*beta**2
[S,T,alpha,beta,U,V] = ordqz(A,B,output='real',sort=select)
eigval = abs(numpy.diag(S)/numpy.diag(T))
return [S,T,U,V,eigval] | python | def qzordered(A,B,crit=1.0):
"Eigenvalues bigger than crit are sorted in the top-left."
TOL = 1e-10
def select(alpha, beta):
return alpha**2>crit*beta**2
[S,T,alpha,beta,U,V] = ordqz(A,B,output='real',sort=select)
eigval = abs(numpy.diag(S)/numpy.diag(T))
return [S,T,U,V,eigval] | [
"def",
"qzordered",
"(",
"A",
",",
"B",
",",
"crit",
"=",
"1.0",
")",
":",
"\"Eigenvalues bigger than crit are sorted in the top-left.\"",
"TOL",
"=",
"1e-10",
"def",
"select",
"(",
"alpha",
",",
"beta",
")",
":",
"return",
"alpha",
"**",
"2",
">",
"crit",
... | Eigenvalues bigger than crit are sorted in the top-left. | [
"Eigenvalues",
"bigger",
"than",
"crit",
"are",
"sorted",
"in",
"the",
"top",
"-",
"left",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/extern/qz.py#L6-L18 | train |
EconForge/dolo | dolo/numeric/extern/qz.py | ordqz | def ordqz(A, B, sort='lhp', output='real', overwrite_a=False,
overwrite_b=False, check_finite=True):
"""
QZ decomposition for a pair of matrices with reordering.
.. versionadded:: 0.17.0
Parameters
----------
A : (N, N) array_like
2d array to decompose
B : (N, N) array_like
2d array to decompose
sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
Specifies whether the upper eigenvalues should be sorted. A callable
may be passed that, given a eigenvalue, returns a boolean denoting
whether the eigenvalue should be sorted to the top-left (True). For
real matrix pairs, the sort function takes three real arguments
(alphar, alphai, beta). The eigenvalue
``x = (alphar + alphai*1j)/beta``. For complex matrix pairs or
output='complex', the sort function takes two complex arguments
(alpha, beta). The eigenvalue ``x = (alpha/beta)``.
Alternatively, string parameters may be used:
- 'lhp' Left-hand plane (x.real < 0.0)
- 'rhp' Right-hand plane (x.real > 0.0)
- 'iuc' Inside the unit circle (x*x.conjugate() < 1.0)
- 'ouc' Outside the unit circle (x*x.conjugate() > 1.0)
output : str {'real','complex'}, optional
Construct the real or complex QZ decomposition for real matrices.
Default is 'real'.
overwrite_a : bool, optional
If True, the contents of A are overwritten.
overwrite_b : bool, optional
If True, the contents of B are overwritten.
check_finite : bool, optional
If true checks the elements of `A` and `B` are finite numbers. If
false does no checking and passes matrix through to
underlying algorithm.
Returns
-------
AA : (N, N) ndarray
Generalized Schur form of A.
BB : (N, N) ndarray
Generalized Schur form of B.
alpha : (N,) ndarray
alpha = alphar + alphai * 1j. See notes.
beta : (N,) ndarray
See notes.
Q : (N, N) ndarray
The left Schur vectors.
Z : (N, N) ndarray
The right Schur vectors.
Notes
-----
On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
generalized eigenvalues. ``ALPHAR(j) + ALPHAI(j)*i`` and
``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
that would result if the 2-by-2 diagonal blocks of the real generalized
Schur form of (A,B) were further reduced to triangular form using complex
unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a complex
conjugate pair, with ``ALPHAI(j+1)`` negative.
See also
--------
qz
"""
import warnings
import numpy as np
from numpy import asarray_chkfinite
from scipy.linalg.misc import LinAlgError, _datacopied
from scipy.linalg.lapack import get_lapack_funcs
from scipy._lib.six import callable
from scipy.linalg._decomp_qz import _qz, _select_function
#NOTE: should users be able to set these?
lwork = None
result, typ = _qz(A, B, output=output, lwork=lwork, sort=None,
overwrite_a=overwrite_a, overwrite_b=overwrite_b,
check_finite=check_finite)
AA, BB, Q, Z = result[0], result[1], result[-4], result[-3]
if typ not in 'cz':
alpha, beta = result[3] + result[4]*1.j, result[5]
else:
alpha, beta = result[3], result[4]
sfunction = _select_function(sort)
select = sfunction(alpha, beta)
tgsen, = get_lapack_funcs(('tgsen',), (AA, BB))
if lwork is None or lwork == -1:
result = tgsen(select, AA, BB, Q, Z, lwork=-1)
lwork = result[-3][0].real.astype(np.int)
# looks like wrong value passed to ZTGSYL if not
lwork += 1
liwork = None
if liwork is None or liwork == -1:
result = tgsen(select, AA, BB, Q, Z, liwork=-1)
liwork = result[-2][0]
result = tgsen(select, AA, BB, Q, Z, lwork=lwork, liwork=liwork)
info = result[-1]
if info < 0:
raise ValueError("Illegal value in argument %d of tgsen" % -info)
elif info == 1:
raise ValueError("Reordering of (A, B) failed because the transformed"
" matrix pair (A, B) would be too far from "
"generalized Schur form; the problem is very "
"ill-conditioned. (A, B) may have been partially "
"reorded. If requested, 0 is returned in DIF(*), "
"PL, and PR.")
# for real results has a, b, alphar, alphai, beta, q, z, m, pl, pr, dif,
# work, iwork, info
if typ in ['f', 'd']:
alpha = result[2] + result[3] * 1.j
return (result[0], result[1], alpha, result[4], result[5], result[6])
# for complex results has a, b, alpha, beta, q, z, m, pl, pr, dif, work,
# iwork, info
else:
return result[0], result[1], result[2], result[3], result[4], result[5] | python | def ordqz(A, B, sort='lhp', output='real', overwrite_a=False,
overwrite_b=False, check_finite=True):
"""
QZ decomposition for a pair of matrices with reordering.
.. versionadded:: 0.17.0
Parameters
----------
A : (N, N) array_like
2d array to decompose
B : (N, N) array_like
2d array to decompose
sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
Specifies whether the upper eigenvalues should be sorted. A callable
may be passed that, given a eigenvalue, returns a boolean denoting
whether the eigenvalue should be sorted to the top-left (True). For
real matrix pairs, the sort function takes three real arguments
(alphar, alphai, beta). The eigenvalue
``x = (alphar + alphai*1j)/beta``. For complex matrix pairs or
output='complex', the sort function takes two complex arguments
(alpha, beta). The eigenvalue ``x = (alpha/beta)``.
Alternatively, string parameters may be used:
- 'lhp' Left-hand plane (x.real < 0.0)
- 'rhp' Right-hand plane (x.real > 0.0)
- 'iuc' Inside the unit circle (x*x.conjugate() < 1.0)
- 'ouc' Outside the unit circle (x*x.conjugate() > 1.0)
output : str {'real','complex'}, optional
Construct the real or complex QZ decomposition for real matrices.
Default is 'real'.
overwrite_a : bool, optional
If True, the contents of A are overwritten.
overwrite_b : bool, optional
If True, the contents of B are overwritten.
check_finite : bool, optional
If true checks the elements of `A` and `B` are finite numbers. If
false does no checking and passes matrix through to
underlying algorithm.
Returns
-------
AA : (N, N) ndarray
Generalized Schur form of A.
BB : (N, N) ndarray
Generalized Schur form of B.
alpha : (N,) ndarray
alpha = alphar + alphai * 1j. See notes.
beta : (N,) ndarray
See notes.
Q : (N, N) ndarray
The left Schur vectors.
Z : (N, N) ndarray
The right Schur vectors.
Notes
-----
On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
generalized eigenvalues. ``ALPHAR(j) + ALPHAI(j)*i`` and
``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
that would result if the 2-by-2 diagonal blocks of the real generalized
Schur form of (A,B) were further reduced to triangular form using complex
unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a complex
conjugate pair, with ``ALPHAI(j+1)`` negative.
See also
--------
qz
"""
import warnings
import numpy as np
from numpy import asarray_chkfinite
from scipy.linalg.misc import LinAlgError, _datacopied
from scipy.linalg.lapack import get_lapack_funcs
from scipy._lib.six import callable
from scipy.linalg._decomp_qz import _qz, _select_function
#NOTE: should users be able to set these?
lwork = None
result, typ = _qz(A, B, output=output, lwork=lwork, sort=None,
overwrite_a=overwrite_a, overwrite_b=overwrite_b,
check_finite=check_finite)
AA, BB, Q, Z = result[0], result[1], result[-4], result[-3]
if typ not in 'cz':
alpha, beta = result[3] + result[4]*1.j, result[5]
else:
alpha, beta = result[3], result[4]
sfunction = _select_function(sort)
select = sfunction(alpha, beta)
tgsen, = get_lapack_funcs(('tgsen',), (AA, BB))
if lwork is None or lwork == -1:
result = tgsen(select, AA, BB, Q, Z, lwork=-1)
lwork = result[-3][0].real.astype(np.int)
# looks like wrong value passed to ZTGSYL if not
lwork += 1
liwork = None
if liwork is None or liwork == -1:
result = tgsen(select, AA, BB, Q, Z, liwork=-1)
liwork = result[-2][0]
result = tgsen(select, AA, BB, Q, Z, lwork=lwork, liwork=liwork)
info = result[-1]
if info < 0:
raise ValueError("Illegal value in argument %d of tgsen" % -info)
elif info == 1:
raise ValueError("Reordering of (A, B) failed because the transformed"
" matrix pair (A, B) would be too far from "
"generalized Schur form; the problem is very "
"ill-conditioned. (A, B) may have been partially "
"reorded. If requested, 0 is returned in DIF(*), "
"PL, and PR.")
# for real results has a, b, alphar, alphai, beta, q, z, m, pl, pr, dif,
# work, iwork, info
if typ in ['f', 'd']:
alpha = result[2] + result[3] * 1.j
return (result[0], result[1], alpha, result[4], result[5], result[6])
# for complex results has a, b, alpha, beta, q, z, m, pl, pr, dif, work,
# iwork, info
else:
return result[0], result[1], result[2], result[3], result[4], result[5] | [
"def",
"ordqz",
"(",
"A",
",",
"B",
",",
"sort",
"=",
"'lhp'",
",",
"output",
"=",
"'real'",
",",
"overwrite_a",
"=",
"False",
",",
"overwrite_b",
"=",
"False",
",",
"check_finite",
"=",
"True",
")",
":",
"import",
"warnings",
"import",
"numpy",
"as",
... | QZ decomposition for a pair of matrices with reordering.
.. versionadded:: 0.17.0
Parameters
----------
A : (N, N) array_like
2d array to decompose
B : (N, N) array_like
2d array to decompose
sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
Specifies whether the upper eigenvalues should be sorted. A callable
may be passed that, given a eigenvalue, returns a boolean denoting
whether the eigenvalue should be sorted to the top-left (True). For
real matrix pairs, the sort function takes three real arguments
(alphar, alphai, beta). The eigenvalue
``x = (alphar + alphai*1j)/beta``. For complex matrix pairs or
output='complex', the sort function takes two complex arguments
(alpha, beta). The eigenvalue ``x = (alpha/beta)``.
Alternatively, string parameters may be used:
- 'lhp' Left-hand plane (x.real < 0.0)
- 'rhp' Right-hand plane (x.real > 0.0)
- 'iuc' Inside the unit circle (x*x.conjugate() < 1.0)
- 'ouc' Outside the unit circle (x*x.conjugate() > 1.0)
output : str {'real','complex'}, optional
Construct the real or complex QZ decomposition for real matrices.
Default is 'real'.
overwrite_a : bool, optional
If True, the contents of A are overwritten.
overwrite_b : bool, optional
If True, the contents of B are overwritten.
check_finite : bool, optional
If true checks the elements of `A` and `B` are finite numbers. If
false does no checking and passes matrix through to
underlying algorithm.
Returns
-------
AA : (N, N) ndarray
Generalized Schur form of A.
BB : (N, N) ndarray
Generalized Schur form of B.
alpha : (N,) ndarray
alpha = alphar + alphai * 1j. See notes.
beta : (N,) ndarray
See notes.
Q : (N, N) ndarray
The left Schur vectors.
Z : (N, N) ndarray
The right Schur vectors.
Notes
-----
On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
generalized eigenvalues. ``ALPHAR(j) + ALPHAI(j)*i`` and
``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
that would result if the 2-by-2 diagonal blocks of the real generalized
Schur form of (A,B) were further reduced to triangular form using complex
unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a complex
conjugate pair, with ``ALPHAI(j+1)`` negative.
See also
--------
qz | [
"QZ",
"decomposition",
"for",
"a",
"pair",
"of",
"matrices",
"with",
"reordering",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/extern/qz.py#L21-L154 | train |
EconForge/dolo | trash/dolo/algos/dtcscc/time_iteration_2.py | parameterized_expectations_direct | def parameterized_expectations_direct(model, verbose=False, initial_dr=None,
pert_order=1, grid={}, distribution={},
maxit=100, tol=1e-8):
'''
Finds a global solution for ``model`` using parameterized expectations
function. Requires the model to be written with controls as a direct
function of the model objects.
The algorithm iterates on the expectations function in the arbitrage
equation. It follows the discussion in section 9.9 of Miranda and
Fackler (2002).
Parameters
----------
model : NumericModel
"dtcscc" model to be solved
verbose : boolean
if True, display iterations
initial_dr : decision rule
initial guess for the decision rule
pert_order : {1}
if no initial guess is supplied, the perturbation solution at order
``pert_order`` is used as initial guess
grid: grid options
distribution: distribution options
maxit: maximum number of iterations
tol: tolerance criterium for successive approximations
Returns
-------
decision rule :
approximated solution
'''
t1 = time.time()
g = model.functions['transition']
d = model.functions['direct_response']
h = model.functions['expectation']
parms = model.calibration['parameters']
if initial_dr is None:
if pert_order == 1:
initial_dr = approximate_controls(model)
if pert_order > 1:
raise Exception("Perturbation order > 1 not supported (yet).")
approx = model.get_grid(**grid)
grid = approx.grid
interp_type = approx.interpolation
dr = create_interpolator(approx, interp_type)
expect = create_interpolator(approx, interp_type)
distrib = model.get_distribution(**distribution)
nodes, weights = distrib.discretize()
N = grid.shape[0]
z = np.zeros((N, len(model.symbols['expectations'])))
x_0 = initial_dr(grid)
x_0 = x_0.real # just in case ...
h_0 = h(grid, x_0, parms)
it = 0
err = 10
err_0 = 10
if verbose:
headline = '|{0:^4} | {1:10} | {2:8} | {3:8} |'
headline = headline.format('N', ' Error', 'Gain', 'Time')
stars = '-'*len(headline)
print(stars)
print(headline)
print(stars)
# format string for within loop
fmt_str = '|{0:4} | {1:10.3e} | {2:8.3f} | {3:8.3f} |'
while err > tol and it <= maxit:
it += 1
t_start = time.time()
# dr.set_values(x_0)
expect.set_values(h_0)
z[...] = 0
for i in range(weights.shape[0]):
e = nodes[i, :]
S = g(grid, x_0, e, parms)
# evaluate expectation over the future state
z += weights[i]*expect(S)
# TODO: check that control is admissible
new_x = d(grid, z, parms)
new_h = h(grid, new_x, parms)
# update error
err = (abs(new_h - h_0).max())
# Update guess for decision rule and expectations function
x_0 = new_x
h_0 = new_h
# print error information if `verbose`
err_SA = err/err_0
err_0 = err
t_finish = time.time()
elapsed = t_finish - t_start
if verbose:
print(fmt_str.format(it, err, err_SA, elapsed))
if it == maxit:
import warnings
warnings.warn(UserWarning("Maximum number of iterations reached"))
# compute final fime and do final printout if `verbose`
t2 = time.time()
if verbose:
print(stars)
print('Elapsed: {} seconds.'.format(t2 - t1))
print(stars)
# Interpolation for the decision rule
dr.set_values(x_0)
return dr | python | def parameterized_expectations_direct(model, verbose=False, initial_dr=None,
pert_order=1, grid={}, distribution={},
maxit=100, tol=1e-8):
'''
Finds a global solution for ``model`` using parameterized expectations
function. Requires the model to be written with controls as a direct
function of the model objects.
The algorithm iterates on the expectations function in the arbitrage
equation. It follows the discussion in section 9.9 of Miranda and
Fackler (2002).
Parameters
----------
model : NumericModel
"dtcscc" model to be solved
verbose : boolean
if True, display iterations
initial_dr : decision rule
initial guess for the decision rule
pert_order : {1}
if no initial guess is supplied, the perturbation solution at order
``pert_order`` is used as initial guess
grid: grid options
distribution: distribution options
maxit: maximum number of iterations
tol: tolerance criterium for successive approximations
Returns
-------
decision rule :
approximated solution
'''
t1 = time.time()
g = model.functions['transition']
d = model.functions['direct_response']
h = model.functions['expectation']
parms = model.calibration['parameters']
if initial_dr is None:
if pert_order == 1:
initial_dr = approximate_controls(model)
if pert_order > 1:
raise Exception("Perturbation order > 1 not supported (yet).")
approx = model.get_grid(**grid)
grid = approx.grid
interp_type = approx.interpolation
dr = create_interpolator(approx, interp_type)
expect = create_interpolator(approx, interp_type)
distrib = model.get_distribution(**distribution)
nodes, weights = distrib.discretize()
N = grid.shape[0]
z = np.zeros((N, len(model.symbols['expectations'])))
x_0 = initial_dr(grid)
x_0 = x_0.real # just in case ...
h_0 = h(grid, x_0, parms)
it = 0
err = 10
err_0 = 10
if verbose:
headline = '|{0:^4} | {1:10} | {2:8} | {3:8} |'
headline = headline.format('N', ' Error', 'Gain', 'Time')
stars = '-'*len(headline)
print(stars)
print(headline)
print(stars)
# format string for within loop
fmt_str = '|{0:4} | {1:10.3e} | {2:8.3f} | {3:8.3f} |'
while err > tol and it <= maxit:
it += 1
t_start = time.time()
# dr.set_values(x_0)
expect.set_values(h_0)
z[...] = 0
for i in range(weights.shape[0]):
e = nodes[i, :]
S = g(grid, x_0, e, parms)
# evaluate expectation over the future state
z += weights[i]*expect(S)
# TODO: check that control is admissible
new_x = d(grid, z, parms)
new_h = h(grid, new_x, parms)
# update error
err = (abs(new_h - h_0).max())
# Update guess for decision rule and expectations function
x_0 = new_x
h_0 = new_h
# print error information if `verbose`
err_SA = err/err_0
err_0 = err
t_finish = time.time()
elapsed = t_finish - t_start
if verbose:
print(fmt_str.format(it, err, err_SA, elapsed))
if it == maxit:
import warnings
warnings.warn(UserWarning("Maximum number of iterations reached"))
# compute final fime and do final printout if `verbose`
t2 = time.time()
if verbose:
print(stars)
print('Elapsed: {} seconds.'.format(t2 - t1))
print(stars)
# Interpolation for the decision rule
dr.set_values(x_0)
return dr | [
"def",
"parameterized_expectations_direct",
"(",
"model",
",",
"verbose",
"=",
"False",
",",
"initial_dr",
"=",
"None",
",",
"pert_order",
"=",
"1",
",",
"grid",
"=",
"{",
"}",
",",
"distribution",
"=",
"{",
"}",
",",
"maxit",
"=",
"100",
",",
"tol",
"... | Finds a global solution for ``model`` using parameterized expectations
function. Requires the model to be written with controls as a direct
function of the model objects.
The algorithm iterates on the expectations function in the arbitrage
equation. It follows the discussion in section 9.9 of Miranda and
Fackler (2002).
Parameters
----------
model : NumericModel
"dtcscc" model to be solved
verbose : boolean
if True, display iterations
initial_dr : decision rule
initial guess for the decision rule
pert_order : {1}
if no initial guess is supplied, the perturbation solution at order
``pert_order`` is used as initial guess
grid: grid options
distribution: distribution options
maxit: maximum number of iterations
tol: tolerance criterium for successive approximations
Returns
-------
decision rule :
approximated solution | [
"Finds",
"a",
"global",
"solution",
"for",
"model",
"using",
"parameterized",
"expectations",
"function",
".",
"Requires",
"the",
"model",
"to",
"be",
"written",
"with",
"controls",
"as",
"a",
"direct",
"function",
"of",
"the",
"model",
"objects",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/trash/dolo/algos/dtcscc/time_iteration_2.py#L186-L312 | train |
EconForge/dolo | dolo/compiler/misc.py | numdiff | def numdiff(fun, args):
"""Vectorized numerical differentiation"""
# vectorized version
epsilon = 1e-8
args = list(args)
v0 = fun(*args)
N = v0.shape[0]
l_v = len(v0)
dvs = []
for i, a in enumerate(args):
l_a = (a).shape[1]
dv = numpy.zeros((N, l_v, l_a))
nargs = list(args) #.copy()
for j in range(l_a):
xx = args[i].copy()
xx[:, j] += epsilon
nargs[i] = xx
dv[:, :, j] = (fun(*nargs) - v0) / epsilon
dvs.append(dv)
return [v0] + dvs | python | def numdiff(fun, args):
"""Vectorized numerical differentiation"""
# vectorized version
epsilon = 1e-8
args = list(args)
v0 = fun(*args)
N = v0.shape[0]
l_v = len(v0)
dvs = []
for i, a in enumerate(args):
l_a = (a).shape[1]
dv = numpy.zeros((N, l_v, l_a))
nargs = list(args) #.copy()
for j in range(l_a):
xx = args[i].copy()
xx[:, j] += epsilon
nargs[i] = xx
dv[:, :, j] = (fun(*nargs) - v0) / epsilon
dvs.append(dv)
return [v0] + dvs | [
"def",
"numdiff",
"(",
"fun",
",",
"args",
")",
":",
"epsilon",
"=",
"1e-8",
"args",
"=",
"list",
"(",
"args",
")",
"v0",
"=",
"fun",
"(",
"*",
"args",
")",
"N",
"=",
"v0",
".",
"shape",
"[",
"0",
"]",
"l_v",
"=",
"len",
"(",
"v0",
")",
"dv... | Vectorized numerical differentiation | [
"Vectorized",
"numerical",
"differentiation"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/compiler/misc.py#L97-L118 | train |
EconForge/dolo | dolo/numeric/filters.py | bandpass_filter | def bandpass_filter(data, k, w1, w2):
"""
This function will apply a bandpass filter to data. It will be kth
order and will select the band between w1 and w2.
Parameters
----------
data: array, dtype=float
The data you wish to filter
k: number, int
The order of approximation for the filter. A max value for
this isdata.size/2
w1: number, float
This is the lower bound for which frequencies will pass
through.
w2: number, float
This is the upper bound for which frequencies will pass
through.
Returns
-------
y: array, dtype=float
The filtered data.
"""
data = np.asarray(data)
low_w = np.pi * 2 / w2
high_w = np.pi * 2 / w1
bweights = np.zeros(2 * k + 1)
bweights[k] = (high_w - low_w) / np.pi
j = np.arange(1, int(k) + 1)
weights = 1 / (np.pi * j) * (sin(high_w * j) - sin(low_w * j))
bweights[k + j] = weights
bweights[:k] = weights[::-1]
bweights -= bweights.mean()
return fftconvolve(bweights, data, mode='valid') | python | def bandpass_filter(data, k, w1, w2):
"""
This function will apply a bandpass filter to data. It will be kth
order and will select the band between w1 and w2.
Parameters
----------
data: array, dtype=float
The data you wish to filter
k: number, int
The order of approximation for the filter. A max value for
this isdata.size/2
w1: number, float
This is the lower bound for which frequencies will pass
through.
w2: number, float
This is the upper bound for which frequencies will pass
through.
Returns
-------
y: array, dtype=float
The filtered data.
"""
data = np.asarray(data)
low_w = np.pi * 2 / w2
high_w = np.pi * 2 / w1
bweights = np.zeros(2 * k + 1)
bweights[k] = (high_w - low_w) / np.pi
j = np.arange(1, int(k) + 1)
weights = 1 / (np.pi * j) * (sin(high_w * j) - sin(low_w * j))
bweights[k + j] = weights
bweights[:k] = weights[::-1]
bweights -= bweights.mean()
return fftconvolve(bweights, data, mode='valid') | [
"def",
"bandpass_filter",
"(",
"data",
",",
"k",
",",
"w1",
",",
"w2",
")",
":",
"data",
"=",
"np",
".",
"asarray",
"(",
"data",
")",
"low_w",
"=",
"np",
".",
"pi",
"*",
"2",
"/",
"w2",
"high_w",
"=",
"np",
".",
"pi",
"*",
"2",
"/",
"w1",
"... | This function will apply a bandpass filter to data. It will be kth
order and will select the band between w1 and w2.
Parameters
----------
data: array, dtype=float
The data you wish to filter
k: number, int
The order of approximation for the filter. A max value for
this isdata.size/2
w1: number, float
This is the lower bound for which frequencies will pass
through.
w2: number, float
This is the upper bound for which frequencies will pass
through.
Returns
-------
y: array, dtype=float
The filtered data. | [
"This",
"function",
"will",
"apply",
"a",
"bandpass",
"filter",
"to",
"data",
".",
"It",
"will",
"be",
"kth",
"order",
"and",
"will",
"select",
"the",
"band",
"between",
"w1",
"and",
"w2",
"."
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/numeric/filters.py#L83-L119 | train |
EconForge/dolo | dolo/misc/dprint.py | dprint | def dprint(s):
'''Prints `s` with additional debugging informations'''
import inspect
frameinfo = inspect.stack()[1]
callerframe = frameinfo.frame
d = callerframe.f_locals
if (isinstance(s,str)):
val = eval(s, d)
else:
val = s
cc = frameinfo.code_context[0]
import re
regex = re.compile("dprint\((.*)\)")
res = regex.search(cc)
s = res.group(1)
text = ''
text += bcolors.OKBLUE + "At <{}>\n".format(str(frameinfo)) + bcolors.ENDC
text += bcolors.WARNING + "{}: ".format(s) + bcolors.ENDC
text += str(val)
text += str()
print(text) | python | def dprint(s):
'''Prints `s` with additional debugging informations'''
import inspect
frameinfo = inspect.stack()[1]
callerframe = frameinfo.frame
d = callerframe.f_locals
if (isinstance(s,str)):
val = eval(s, d)
else:
val = s
cc = frameinfo.code_context[0]
import re
regex = re.compile("dprint\((.*)\)")
res = regex.search(cc)
s = res.group(1)
text = ''
text += bcolors.OKBLUE + "At <{}>\n".format(str(frameinfo)) + bcolors.ENDC
text += bcolors.WARNING + "{}: ".format(s) + bcolors.ENDC
text += str(val)
text += str()
print(text) | [
"def",
"dprint",
"(",
"s",
")",
":",
"import",
"inspect",
"frameinfo",
"=",
"inspect",
".",
"stack",
"(",
")",
"[",
"1",
"]",
"callerframe",
"=",
"frameinfo",
".",
"frame",
"d",
"=",
"callerframe",
".",
"f_locals",
"if",
"(",
"isinstance",
"(",
"s",
... | Prints `s` with additional debugging informations | [
"Prints",
"s",
"with",
"additional",
"debugging",
"informations"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/misc/dprint.py#L21-L46 | train |
EconForge/dolo | dolo/compiler/function_compiler_sympy.py | non_decreasing_series | def non_decreasing_series(n, size):
'''Lists all combinations of 0,...,n-1 in increasing order'''
if size == 1:
return [[a] for a in range(n)]
else:
lc = non_decreasing_series(n, size-1)
ll = []
for l in lc:
last = l[-1]
for i in range(last, n):
e = l + [i]
ll.append(e)
return ll | python | def non_decreasing_series(n, size):
'''Lists all combinations of 0,...,n-1 in increasing order'''
if size == 1:
return [[a] for a in range(n)]
else:
lc = non_decreasing_series(n, size-1)
ll = []
for l in lc:
last = l[-1]
for i in range(last, n):
e = l + [i]
ll.append(e)
return ll | [
"def",
"non_decreasing_series",
"(",
"n",
",",
"size",
")",
":",
"if",
"size",
"==",
"1",
":",
"return",
"[",
"[",
"a",
"]",
"for",
"a",
"in",
"range",
"(",
"n",
")",
"]",
"else",
":",
"lc",
"=",
"non_decreasing_series",
"(",
"n",
",",
"size",
"-... | Lists all combinations of 0,...,n-1 in increasing order | [
"Lists",
"all",
"combinations",
"of",
"0",
"...",
"n",
"-",
"1",
"in",
"increasing",
"order"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/compiler/function_compiler_sympy.py#L13-L26 | train |
EconForge/dolo | dolo/compiler/function_compiler_sympy.py | higher_order_diff | def higher_order_diff(eqs, syms, order=2):
'''Takes higher order derivatives of a list of equations w.r.t a list of paramters'''
import numpy
eqs = list([sympy.sympify(eq) for eq in eqs])
syms = list([sympy.sympify(s) for s in syms])
neq = len(eqs)
p = len(syms)
D = [numpy.array(eqs)]
orders = []
for i in range(1,order+1):
par = D[i-1]
mat = numpy.empty([neq] + [p]*i, dtype=object) #.append( numpy.zeros(orders))
for ind in non_decreasing_series(p,i):
ind_parent = ind[:-1]
k = ind[-1]
for line in range(neq):
ii = [line] + ind
iid = [line] + ind_parent
eeq = par[ tuple(iid) ]
mat[tuple(ii)] = eeq.diff(syms[k])
D.append(mat)
return D | python | def higher_order_diff(eqs, syms, order=2):
'''Takes higher order derivatives of a list of equations w.r.t a list of paramters'''
import numpy
eqs = list([sympy.sympify(eq) for eq in eqs])
syms = list([sympy.sympify(s) for s in syms])
neq = len(eqs)
p = len(syms)
D = [numpy.array(eqs)]
orders = []
for i in range(1,order+1):
par = D[i-1]
mat = numpy.empty([neq] + [p]*i, dtype=object) #.append( numpy.zeros(orders))
for ind in non_decreasing_series(p,i):
ind_parent = ind[:-1]
k = ind[-1]
for line in range(neq):
ii = [line] + ind
iid = [line] + ind_parent
eeq = par[ tuple(iid) ]
mat[tuple(ii)] = eeq.diff(syms[k])
D.append(mat)
return D | [
"def",
"higher_order_diff",
"(",
"eqs",
",",
"syms",
",",
"order",
"=",
"2",
")",
":",
"import",
"numpy",
"eqs",
"=",
"list",
"(",
"[",
"sympy",
".",
"sympify",
"(",
"eq",
")",
"for",
"eq",
"in",
"eqs",
"]",
")",
"syms",
"=",
"list",
"(",
"[",
... | Takes higher order derivatives of a list of equations w.r.t a list of paramters | [
"Takes",
"higher",
"order",
"derivatives",
"of",
"a",
"list",
"of",
"equations",
"w",
".",
"r",
".",
"t",
"a",
"list",
"of",
"paramters"
] | d91ddf148b009bf79852d9aec70f3a1877e0f79a | https://github.com/EconForge/dolo/blob/d91ddf148b009bf79852d9aec70f3a1877e0f79a/dolo/compiler/function_compiler_sympy.py#L28-L60 | train |
pokerregion/poker | poker/website/pocketfives.py | get_ranked_players | def get_ranked_players():
"""Get the list of the first 100 ranked players."""
rankings_page = requests.get(RANKINGS_URL)
root = etree.HTML(rankings_page.text)
player_rows = root.xpath('//div[@id="ranked"]//tr')
for row in player_rows[1:]:
player_row = row.xpath('td[@class!="country"]//text()')
yield _Player(
name=player_row[1],
country=row[1][0].get('title'),
triple_crowns=player_row[3],
monthly_win=player_row[4],
biggest_cash=player_row[5],
plb_score=player_row[6],
biggest_score=player_row[7],
average_score=player_row[8],
previous_rank=player_row[9],
) | python | def get_ranked_players():
"""Get the list of the first 100 ranked players."""
rankings_page = requests.get(RANKINGS_URL)
root = etree.HTML(rankings_page.text)
player_rows = root.xpath('//div[@id="ranked"]//tr')
for row in player_rows[1:]:
player_row = row.xpath('td[@class!="country"]//text()')
yield _Player(
name=player_row[1],
country=row[1][0].get('title'),
triple_crowns=player_row[3],
monthly_win=player_row[4],
biggest_cash=player_row[5],
plb_score=player_row[6],
biggest_score=player_row[7],
average_score=player_row[8],
previous_rank=player_row[9],
) | [
"def",
"get_ranked_players",
"(",
")",
":",
"rankings_page",
"=",
"requests",
".",
"get",
"(",
"RANKINGS_URL",
")",
"root",
"=",
"etree",
".",
"HTML",
"(",
"rankings_page",
".",
"text",
")",
"player_rows",
"=",
"root",
".",
"xpath",
"(",
"'//div[@id=\"ranked... | Get the list of the first 100 ranked players. | [
"Get",
"the",
"list",
"of",
"the",
"first",
"100",
"ranked",
"players",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/website/pocketfives.py#L31-L50 | train |
pokerregion/poker | poker/card.py | Rank.difference | def difference(cls, first, second):
"""Tells the numerical difference between two ranks."""
# so we always get a Rank instance even if string were passed in
first, second = cls(first), cls(second)
rank_list = list(cls)
return abs(rank_list.index(first) - rank_list.index(second)) | python | def difference(cls, first, second):
"""Tells the numerical difference between two ranks."""
# so we always get a Rank instance even if string were passed in
first, second = cls(first), cls(second)
rank_list = list(cls)
return abs(rank_list.index(first) - rank_list.index(second)) | [
"def",
"difference",
"(",
"cls",
",",
"first",
",",
"second",
")",
":",
"first",
",",
"second",
"=",
"cls",
"(",
"first",
")",
",",
"cls",
"(",
"second",
")",
"rank_list",
"=",
"list",
"(",
"cls",
")",
"return",
"abs",
"(",
"rank_list",
".",
"index... | Tells the numerical difference between two ranks. | [
"Tells",
"the",
"numerical",
"difference",
"between",
"two",
"ranks",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/card.py#L42-L48 | train |
pokerregion/poker | poker/card.py | _CardMeta.make_random | def make_random(cls):
"""Returns a random Card instance."""
self = object.__new__(cls)
self.rank = Rank.make_random()
self.suit = Suit.make_random()
return self | python | def make_random(cls):
"""Returns a random Card instance."""
self = object.__new__(cls)
self.rank = Rank.make_random()
self.suit = Suit.make_random()
return self | [
"def",
"make_random",
"(",
"cls",
")",
":",
"self",
"=",
"object",
".",
"__new__",
"(",
"cls",
")",
"self",
".",
"rank",
"=",
"Rank",
".",
"make_random",
"(",
")",
"self",
".",
"suit",
"=",
"Suit",
".",
"make_random",
"(",
")",
"return",
"self"
] | Returns a random Card instance. | [
"Returns",
"a",
"random",
"Card",
"instance",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/card.py#L64-L69 | train |
pokerregion/poker | poker/commands.py | twoplustwo_player | def twoplustwo_player(username):
"""Get profile information about a Two plus Two Forum member given the username."""
from .website.twoplustwo import ForumMember, AmbiguousUserNameError, UserNotFoundError
try:
member = ForumMember(username)
except UserNotFoundError:
raise click.ClickException('User "%s" not found!' % username)
except AmbiguousUserNameError as e:
click.echo('Got multiple users with similar names!', err=True)
for ind, user in enumerate(e.users):
click.echo('{}. {}'.format(ind + 1, user.name), err=True)
number = click.prompt('Which would you like to see [{}-{}]'.format(1, len(e.users)),
prompt_suffix='? ', type=click.IntRange(1, len(e.users)), err=True)
userid = e.users[int(number) - 1].id
member = ForumMember.from_userid(userid)
click.echo(err=True) # empty line after input
_print_header('Two plus two forum member')
_print_values(
('Username', member.username),
('Forum id', member.id),
('Location', member.location),
('Total posts', member.total_posts),
('Posts per day', member.posts_per_day),
('Rank', member.rank),
('Last activity', member.last_activity),
('Join date', member.join_date),
('Usergroups', member.public_usergroups),
('Profile picture', member.profile_picture),
('Avatar', member.avatar),
) | python | def twoplustwo_player(username):
"""Get profile information about a Two plus Two Forum member given the username."""
from .website.twoplustwo import ForumMember, AmbiguousUserNameError, UserNotFoundError
try:
member = ForumMember(username)
except UserNotFoundError:
raise click.ClickException('User "%s" not found!' % username)
except AmbiguousUserNameError as e:
click.echo('Got multiple users with similar names!', err=True)
for ind, user in enumerate(e.users):
click.echo('{}. {}'.format(ind + 1, user.name), err=True)
number = click.prompt('Which would you like to see [{}-{}]'.format(1, len(e.users)),
prompt_suffix='? ', type=click.IntRange(1, len(e.users)), err=True)
userid = e.users[int(number) - 1].id
member = ForumMember.from_userid(userid)
click.echo(err=True) # empty line after input
_print_header('Two plus two forum member')
_print_values(
('Username', member.username),
('Forum id', member.id),
('Location', member.location),
('Total posts', member.total_posts),
('Posts per day', member.posts_per_day),
('Rank', member.rank),
('Last activity', member.last_activity),
('Join date', member.join_date),
('Usergroups', member.public_usergroups),
('Profile picture', member.profile_picture),
('Avatar', member.avatar),
) | [
"def",
"twoplustwo_player",
"(",
"username",
")",
":",
"from",
".",
"website",
".",
"twoplustwo",
"import",
"ForumMember",
",",
"AmbiguousUserNameError",
",",
"UserNotFoundError",
"try",
":",
"member",
"=",
"ForumMember",
"(",
"username",
")",
"except",
"UserNotFo... | Get profile information about a Two plus Two Forum member given the username. | [
"Get",
"profile",
"information",
"about",
"a",
"Two",
"plus",
"Two",
"Forum",
"member",
"given",
"the",
"username",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/commands.py#L59-L95 | train |
pokerregion/poker | poker/commands.py | p5list | def p5list(num):
"""List pocketfives ranked players, max 100 if no NUM, or NUM if specified."""
from .website.pocketfives import get_ranked_players
format_str = '{:>4.4} {!s:<15.13}{!s:<18.15}{!s:<9.6}{!s:<10.7}'\
'{!s:<14.11}{!s:<12.9}{!s:<12.9}{!s:<12.9}{!s:<4.4}'
click.echo(format_str.format(
'Rank' , 'Player name', 'Country', 'Triple', 'Monthly', 'Biggest cash',
'PLB score', 'Biggest s', 'Average s', 'Prev'
))
# just generate the appropriate number of underlines and cut them with format_str
underlines = ['-' * 20] * 10
click.echo(format_str.format(*underlines))
for ind, player in enumerate(get_ranked_players()):
click.echo(format_str.format(str(ind + 1) + '.', *player))
if ind == num - 1:
break | python | def p5list(num):
"""List pocketfives ranked players, max 100 if no NUM, or NUM if specified."""
from .website.pocketfives import get_ranked_players
format_str = '{:>4.4} {!s:<15.13}{!s:<18.15}{!s:<9.6}{!s:<10.7}'\
'{!s:<14.11}{!s:<12.9}{!s:<12.9}{!s:<12.9}{!s:<4.4}'
click.echo(format_str.format(
'Rank' , 'Player name', 'Country', 'Triple', 'Monthly', 'Biggest cash',
'PLB score', 'Biggest s', 'Average s', 'Prev'
))
# just generate the appropriate number of underlines and cut them with format_str
underlines = ['-' * 20] * 10
click.echo(format_str.format(*underlines))
for ind, player in enumerate(get_ranked_players()):
click.echo(format_str.format(str(ind + 1) + '.', *player))
if ind == num - 1:
break | [
"def",
"p5list",
"(",
"num",
")",
":",
"from",
".",
"website",
".",
"pocketfives",
"import",
"get_ranked_players",
"format_str",
"=",
"'{:>4.4} {!s:<15.13}{!s:<18.15}{!s:<9.6}{!s:<10.7}'",
"'{!s:<14.11}{!s:<12.9}{!s:<12.9}{!s:<12.9}{!s:<4.4}'",
"click",
".",
"echo",
"(",
... | List pocketfives ranked players, max 100 if no NUM, or NUM if specified. | [
"List",
"pocketfives",
"ranked",
"players",
"max",
"100",
"if",
"no",
"NUM",
"or",
"NUM",
"if",
"specified",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/commands.py#L100-L119 | train |
pokerregion/poker | poker/commands.py | psstatus | def psstatus():
"""Shows PokerStars status such as number of players, tournaments."""
from .website.pokerstars import get_status
_print_header('PokerStars status')
status = get_status()
_print_values(
('Info updated', status.updated),
('Tables', status.tables),
('Players', status.players),
('Active tournaments', status.active_tournaments),
('Total tournaments', status.total_tournaments),
('Clubs', status.clubs),
('Club members', status.club_members),
)
site_format_str = '{0.id:<12} {0.tables:<7,} {0.players:<8,} {0.active_tournaments:,}'
click.echo('\nSite Tables Players Tournaments')
click.echo('----------- ------ ------- -----------')
for site in status.sites:
click.echo(site_format_str.format(site)) | python | def psstatus():
"""Shows PokerStars status such as number of players, tournaments."""
from .website.pokerstars import get_status
_print_header('PokerStars status')
status = get_status()
_print_values(
('Info updated', status.updated),
('Tables', status.tables),
('Players', status.players),
('Active tournaments', status.active_tournaments),
('Total tournaments', status.total_tournaments),
('Clubs', status.clubs),
('Club members', status.club_members),
)
site_format_str = '{0.id:<12} {0.tables:<7,} {0.players:<8,} {0.active_tournaments:,}'
click.echo('\nSite Tables Players Tournaments')
click.echo('----------- ------ ------- -----------')
for site in status.sites:
click.echo(site_format_str.format(site)) | [
"def",
"psstatus",
"(",
")",
":",
"from",
".",
"website",
".",
"pokerstars",
"import",
"get_status",
"_print_header",
"(",
"'PokerStars status'",
")",
"status",
"=",
"get_status",
"(",
")",
"_print_values",
"(",
"(",
"'Info updated'",
",",
"status",
".",
"upda... | Shows PokerStars status such as number of players, tournaments. | [
"Shows",
"PokerStars",
"status",
"such",
"as",
"number",
"of",
"players",
"tournaments",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/commands.py#L123-L145 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.notes | def notes(self):
"""Tuple of notes.."""
return tuple(self._get_note_data(note) for note in self.root.iter('note')) | python | def notes(self):
"""Tuple of notes.."""
return tuple(self._get_note_data(note) for note in self.root.iter('note')) | [
"def",
"notes",
"(",
"self",
")",
":",
"return",
"tuple",
"(",
"self",
".",
"_get_note_data",
"(",
"note",
")",
"for",
"note",
"in",
"self",
".",
"root",
".",
"iter",
"(",
"'note'",
")",
")"
] | Tuple of notes.. | [
"Tuple",
"of",
"notes",
".."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L335-L337 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.labels | def labels(self):
"""Tuple of labels."""
return tuple(_Label(label.get('id'), label.get('color'), label.text) for label
in self.root.iter('label')) | python | def labels(self):
"""Tuple of labels."""
return tuple(_Label(label.get('id'), label.get('color'), label.text) for label
in self.root.iter('label')) | [
"def",
"labels",
"(",
"self",
")",
":",
"return",
"tuple",
"(",
"_Label",
"(",
"label",
".",
"get",
"(",
"'id'",
")",
",",
"label",
".",
"get",
"(",
"'color'",
")",
",",
"label",
".",
"text",
")",
"for",
"label",
"in",
"self",
".",
"root",
".",
... | Tuple of labels. | [
"Tuple",
"of",
"labels",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L340-L343 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.add_note | def add_note(self, player, text, label=None, update=None):
"""Add a note to the xml. If update param is None, it will be the current time."""
if label is not None and (label not in self.label_names):
raise LabelNotFoundError('Invalid label: {}'.format(label))
if update is None:
update = datetime.utcnow()
# converted to timestamp, rounded to ones
update = update.strftime('%s')
label_id = self._get_label_id(label)
new_note = etree.Element('note', player=player, label=label_id, update=update)
new_note.text = text
self.root.append(new_note) | python | def add_note(self, player, text, label=None, update=None):
"""Add a note to the xml. If update param is None, it will be the current time."""
if label is not None and (label not in self.label_names):
raise LabelNotFoundError('Invalid label: {}'.format(label))
if update is None:
update = datetime.utcnow()
# converted to timestamp, rounded to ones
update = update.strftime('%s')
label_id = self._get_label_id(label)
new_note = etree.Element('note', player=player, label=label_id, update=update)
new_note.text = text
self.root.append(new_note) | [
"def",
"add_note",
"(",
"self",
",",
"player",
",",
"text",
",",
"label",
"=",
"None",
",",
"update",
"=",
"None",
")",
":",
"if",
"label",
"is",
"not",
"None",
"and",
"(",
"label",
"not",
"in",
"self",
".",
"label_names",
")",
":",
"raise",
"Label... | Add a note to the xml. If update param is None, it will be the current time. | [
"Add",
"a",
"note",
"to",
"the",
"xml",
".",
"If",
"update",
"param",
"is",
"None",
"it",
"will",
"be",
"the",
"current",
"time",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L354-L365 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.append_note | def append_note(self, player, text):
"""Append text to an already existing note."""
note = self._find_note(player)
note.text += text | python | def append_note(self, player, text):
"""Append text to an already existing note."""
note = self._find_note(player)
note.text += text | [
"def",
"append_note",
"(",
"self",
",",
"player",
",",
"text",
")",
":",
"note",
"=",
"self",
".",
"_find_note",
"(",
"player",
")",
"note",
".",
"text",
"+=",
"text"
] | Append text to an already existing note. | [
"Append",
"text",
"to",
"an",
"already",
"existing",
"note",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L367-L370 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.prepend_note | def prepend_note(self, player, text):
"""Prepend text to an already existing note."""
note = self._find_note(player)
note.text = text + note.text | python | def prepend_note(self, player, text):
"""Prepend text to an already existing note."""
note = self._find_note(player)
note.text = text + note.text | [
"def",
"prepend_note",
"(",
"self",
",",
"player",
",",
"text",
")",
":",
"note",
"=",
"self",
".",
"_find_note",
"(",
"player",
")",
"note",
".",
"text",
"=",
"text",
"+",
"note",
".",
"text"
] | Prepend text to an already existing note. | [
"Prepend",
"text",
"to",
"an",
"already",
"existing",
"note",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L372-L375 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.get_label | def get_label(self, name):
"""Find the label by name."""
label_tag = self._find_label(name)
return _Label(label_tag.get('id'), label_tag.get('color'), label_tag.text) | python | def get_label(self, name):
"""Find the label by name."""
label_tag = self._find_label(name)
return _Label(label_tag.get('id'), label_tag.get('color'), label_tag.text) | [
"def",
"get_label",
"(",
"self",
",",
"name",
")",
":",
"label_tag",
"=",
"self",
".",
"_find_label",
"(",
"name",
")",
"return",
"_Label",
"(",
"label_tag",
".",
"get",
"(",
"'id'",
")",
",",
"label_tag",
".",
"get",
"(",
"'color'",
")",
",",
"label... | Find the label by name. | [
"Find",
"the",
"label",
"by",
"name",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L412-L415 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.add_label | def add_label(self, name, color):
"""Add a new label. It's id will automatically be calculated."""
color_upper = color.upper()
if not self._color_re.match(color_upper):
raise ValueError('Invalid color: {}'.format(color))
labels_tag = self.root[0]
last_id = int(labels_tag[-1].get('id'))
new_id = str(last_id + 1)
new_label = etree.Element('label', id=new_id, color=color_upper)
new_label.text = name
labels_tag.append(new_label) | python | def add_label(self, name, color):
"""Add a new label. It's id will automatically be calculated."""
color_upper = color.upper()
if not self._color_re.match(color_upper):
raise ValueError('Invalid color: {}'.format(color))
labels_tag = self.root[0]
last_id = int(labels_tag[-1].get('id'))
new_id = str(last_id + 1)
new_label = etree.Element('label', id=new_id, color=color_upper)
new_label.text = name
labels_tag.append(new_label) | [
"def",
"add_label",
"(",
"self",
",",
"name",
",",
"color",
")",
":",
"color_upper",
"=",
"color",
".",
"upper",
"(",
")",
"if",
"not",
"self",
".",
"_color_re",
".",
"match",
"(",
"color_upper",
")",
":",
"raise",
"ValueError",
"(",
"'Invalid color: {}'... | Add a new label. It's id will automatically be calculated. | [
"Add",
"a",
"new",
"label",
".",
"It",
"s",
"id",
"will",
"automatically",
"be",
"calculated",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L417-L430 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.del_label | def del_label(self, name):
"""Delete a label by name."""
labels_tag = self.root[0]
labels_tag.remove(self._find_label(name)) | python | def del_label(self, name):
"""Delete a label by name."""
labels_tag = self.root[0]
labels_tag.remove(self._find_label(name)) | [
"def",
"del_label",
"(",
"self",
",",
"name",
")",
":",
"labels_tag",
"=",
"self",
".",
"root",
"[",
"0",
"]",
"labels_tag",
".",
"remove",
"(",
"self",
".",
"_find_label",
"(",
"name",
")",
")"
] | Delete a label by name. | [
"Delete",
"a",
"label",
"by",
"name",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L432-L435 | train |
pokerregion/poker | poker/room/pokerstars.py | Notes.save | def save(self, filename):
"""Save the note XML to a file."""
with open(filename, 'w') as fp:
fp.write(str(self)) | python | def save(self, filename):
"""Save the note XML to a file."""
with open(filename, 'w') as fp:
fp.write(str(self)) | [
"def",
"save",
"(",
"self",
",",
"filename",
")",
":",
"with",
"open",
"(",
"filename",
",",
"'w'",
")",
"as",
"fp",
":",
"fp",
".",
"write",
"(",
"str",
"(",
"self",
")",
")"
] | Save the note XML to a file. | [
"Save",
"the",
"note",
"XML",
"to",
"a",
"file",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/room/pokerstars.py#L447-L450 | train |
pokerregion/poker | poker/handhistory.py | _BaseHandHistory.board | def board(self):
"""Calculates board from flop, turn and river."""
board = []
if self.flop:
board.extend(self.flop.cards)
if self.turn:
board.append(self.turn)
if self.river:
board.append(self.river)
return tuple(board) if board else None | python | def board(self):
"""Calculates board from flop, turn and river."""
board = []
if self.flop:
board.extend(self.flop.cards)
if self.turn:
board.append(self.turn)
if self.river:
board.append(self.river)
return tuple(board) if board else None | [
"def",
"board",
"(",
"self",
")",
":",
"board",
"=",
"[",
"]",
"if",
"self",
".",
"flop",
":",
"board",
".",
"extend",
"(",
"self",
".",
"flop",
".",
"cards",
")",
"if",
"self",
".",
"turn",
":",
"board",
".",
"append",
"(",
"self",
".",
"turn"... | Calculates board from flop, turn and river. | [
"Calculates",
"board",
"from",
"flop",
"turn",
"and",
"river",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/handhistory.py#L167-L176 | train |
pokerregion/poker | poker/handhistory.py | _BaseHandHistory._parse_date | def _parse_date(self, date_string):
"""Parse the date_string and return a datetime object as UTC."""
date = datetime.strptime(date_string, self._DATE_FORMAT)
self.date = self._TZ.localize(date).astimezone(pytz.UTC) | python | def _parse_date(self, date_string):
"""Parse the date_string and return a datetime object as UTC."""
date = datetime.strptime(date_string, self._DATE_FORMAT)
self.date = self._TZ.localize(date).astimezone(pytz.UTC) | [
"def",
"_parse_date",
"(",
"self",
",",
"date_string",
")",
":",
"date",
"=",
"datetime",
".",
"strptime",
"(",
"date_string",
",",
"self",
".",
"_DATE_FORMAT",
")",
"self",
".",
"date",
"=",
"self",
".",
"_TZ",
".",
"localize",
"(",
"date",
")",
".",
... | Parse the date_string and return a datetime object as UTC. | [
"Parse",
"the",
"date_string",
"and",
"return",
"a",
"datetime",
"object",
"as",
"UTC",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/handhistory.py#L178-L181 | train |
pokerregion/poker | poker/handhistory.py | _SplittableHandHistoryMixin._split_raw | def _split_raw(self):
"""Split hand history by sections."""
self._splitted = self._split_re.split(self.raw)
# search split locations (basically empty strings)
self._sections = [ind for ind, elem in enumerate(self._splitted) if not elem] | python | def _split_raw(self):
"""Split hand history by sections."""
self._splitted = self._split_re.split(self.raw)
# search split locations (basically empty strings)
self._sections = [ind for ind, elem in enumerate(self._splitted) if not elem] | [
"def",
"_split_raw",
"(",
"self",
")",
":",
"self",
".",
"_splitted",
"=",
"self",
".",
"_split_re",
".",
"split",
"(",
"self",
".",
"raw",
")",
"self",
".",
"_sections",
"=",
"[",
"ind",
"for",
"ind",
",",
"elem",
"in",
"enumerate",
"(",
"self",
"... | Split hand history by sections. | [
"Split",
"hand",
"history",
"by",
"sections",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/handhistory.py#L201-L206 | train |
pokerregion/poker | poker/website/twoplustwo.py | ForumMember._get_timezone | def _get_timezone(self, root):
"""Find timezone informatation on bottom of the page."""
tz_str = root.xpath('//div[@class="smallfont" and @align="center"]')[0].text
hours = int(self._tz_re.search(tz_str).group(1))
return tzoffset(tz_str, hours * 60) | python | def _get_timezone(self, root):
"""Find timezone informatation on bottom of the page."""
tz_str = root.xpath('//div[@class="smallfont" and @align="center"]')[0].text
hours = int(self._tz_re.search(tz_str).group(1))
return tzoffset(tz_str, hours * 60) | [
"def",
"_get_timezone",
"(",
"self",
",",
"root",
")",
":",
"tz_str",
"=",
"root",
".",
"xpath",
"(",
"'//div[@class=\"smallfont\" and @align=\"center\"]'",
")",
"[",
"0",
"]",
".",
"text",
"hours",
"=",
"int",
"(",
"self",
".",
"_tz_re",
".",
"search",
"(... | Find timezone informatation on bottom of the page. | [
"Find",
"timezone",
"informatation",
"on",
"bottom",
"of",
"the",
"page",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/website/twoplustwo.py#L125-L129 | train |
pokerregion/poker | poker/website/pokerstars.py | get_current_tournaments | def get_current_tournaments():
"""Get the next 200 tournaments from pokerstars."""
schedule_page = requests.get(TOURNAMENTS_XML_URL)
root = etree.XML(schedule_page.content)
for tour in root.iter('{*}tournament'):
yield _Tournament(
start_date=tour.findtext('{*}start_date'),
name=tour.findtext('{*}name'),
game=tour.findtext('{*}game'),
buyin=tour.findtext('{*}buy_in_fee'),
players=tour.get('players')
) | python | def get_current_tournaments():
"""Get the next 200 tournaments from pokerstars."""
schedule_page = requests.get(TOURNAMENTS_XML_URL)
root = etree.XML(schedule_page.content)
for tour in root.iter('{*}tournament'):
yield _Tournament(
start_date=tour.findtext('{*}start_date'),
name=tour.findtext('{*}name'),
game=tour.findtext('{*}game'),
buyin=tour.findtext('{*}buy_in_fee'),
players=tour.get('players')
) | [
"def",
"get_current_tournaments",
"(",
")",
":",
"schedule_page",
"=",
"requests",
".",
"get",
"(",
"TOURNAMENTS_XML_URL",
")",
"root",
"=",
"etree",
".",
"XML",
"(",
"schedule_page",
".",
"content",
")",
"for",
"tour",
"in",
"root",
".",
"iter",
"(",
"'{*... | Get the next 200 tournaments from pokerstars. | [
"Get",
"the",
"next",
"200",
"tournaments",
"from",
"pokerstars",
"."
] | 2d8cf208fdf2b26bdc935972dcbe7a983a9e9768 | https://github.com/pokerregion/poker/blob/2d8cf208fdf2b26bdc935972dcbe7a983a9e9768/poker/website/pokerstars.py#L29-L42 | train |
RKrahl/pytest-dependency | setup.py | _filter_file | def _filter_file(src, dest, subst):
"""Copy src to dest doing substitutions on the fly.
"""
substre = re.compile(r'\$(%s)' % '|'.join(subst.keys()))
def repl(m):
return subst[m.group(1)]
with open(src, "rt") as sf, open(dest, "wt") as df:
while True:
l = sf.readline()
if not l:
break
df.write(re.sub(substre, repl, l)) | python | def _filter_file(src, dest, subst):
"""Copy src to dest doing substitutions on the fly.
"""
substre = re.compile(r'\$(%s)' % '|'.join(subst.keys()))
def repl(m):
return subst[m.group(1)]
with open(src, "rt") as sf, open(dest, "wt") as df:
while True:
l = sf.readline()
if not l:
break
df.write(re.sub(substre, repl, l)) | [
"def",
"_filter_file",
"(",
"src",
",",
"dest",
",",
"subst",
")",
":",
"substre",
"=",
"re",
".",
"compile",
"(",
"r'\\$(%s)'",
"%",
"'|'",
".",
"join",
"(",
"subst",
".",
"keys",
"(",
")",
")",
")",
"def",
"repl",
"(",
"m",
")",
":",
"return",
... | Copy src to dest doing substitutions on the fly. | [
"Copy",
"src",
"to",
"dest",
"doing",
"substitutions",
"on",
"the",
"fly",
"."
] | 7b7c10818266ec4b05c36c341cf84f05d7ab53ce | https://github.com/RKrahl/pytest-dependency/blob/7b7c10818266ec4b05c36c341cf84f05d7ab53ce/setup.py#L18-L29 | train |
profusion/sgqlc | sgqlc/endpoint/base.py | BaseEndpoint._fixup_graphql_error | def _fixup_graphql_error(self, data):
'''Given a possible GraphQL error payload, make sure it's in shape.
This will ensure the given ``data`` is in the shape:
.. code-block:: json
{"errors": [{"message": "some string"}]}
If ``errors`` is not an array, it will be made into a single element
array, with the object in that format, with its string representation
being the message.
If an element of the ``errors`` array is not in the format, then
it's converted to the format, with its string representation being
the message.
The input object is not changed, a copy is made if needed.
:return: the given ``data`` formatted to the correct shape, a copy
is made and returned if any fix up was needed.
:rtype: dict
'''
original_data = data
errors = data.get('errors')
original_errors = errors
if not isinstance(errors, list):
self.logger.warning('data["errors"] is not a list! Fix up data=%r',
data)
data = data.copy()
data['errors'] = [{'message': str(errors)}]
return data
for i, error in enumerate(errors):
if not isinstance(error, dict):
self.logger.warning('Error #%d: is not a dict: %r. Fix up!',
i, error)
if data is original_data:
data = data.copy()
if errors is original_errors:
errors = errors.copy()
data['errors'] = errors
errors[i] = {'message': str(error)}
continue
message = error.get('message')
if not isinstance(message, str):
if data is original_data:
data = data.copy()
if errors is original_errors:
errors = errors.copy()
data['errors'] = errors
message = str(error) if message is None else str(message)
error = error.copy()
error['message'] = message
errors[i] = error
return data | python | def _fixup_graphql_error(self, data):
'''Given a possible GraphQL error payload, make sure it's in shape.
This will ensure the given ``data`` is in the shape:
.. code-block:: json
{"errors": [{"message": "some string"}]}
If ``errors`` is not an array, it will be made into a single element
array, with the object in that format, with its string representation
being the message.
If an element of the ``errors`` array is not in the format, then
it's converted to the format, with its string representation being
the message.
The input object is not changed, a copy is made if needed.
:return: the given ``data`` formatted to the correct shape, a copy
is made and returned if any fix up was needed.
:rtype: dict
'''
original_data = data
errors = data.get('errors')
original_errors = errors
if not isinstance(errors, list):
self.logger.warning('data["errors"] is not a list! Fix up data=%r',
data)
data = data.copy()
data['errors'] = [{'message': str(errors)}]
return data
for i, error in enumerate(errors):
if not isinstance(error, dict):
self.logger.warning('Error #%d: is not a dict: %r. Fix up!',
i, error)
if data is original_data:
data = data.copy()
if errors is original_errors:
errors = errors.copy()
data['errors'] = errors
errors[i] = {'message': str(error)}
continue
message = error.get('message')
if not isinstance(message, str):
if data is original_data:
data = data.copy()
if errors is original_errors:
errors = errors.copy()
data['errors'] = errors
message = str(error) if message is None else str(message)
error = error.copy()
error['message'] = message
errors[i] = error
return data | [
"def",
"_fixup_graphql_error",
"(",
"self",
",",
"data",
")",
":",
"original_data",
"=",
"data",
"errors",
"=",
"data",
".",
"get",
"(",
"'errors'",
")",
"original_errors",
"=",
"errors",
"if",
"not",
"isinstance",
"(",
"errors",
",",
"list",
")",
":",
"... | Given a possible GraphQL error payload, make sure it's in shape.
This will ensure the given ``data`` is in the shape:
.. code-block:: json
{"errors": [{"message": "some string"}]}
If ``errors`` is not an array, it will be made into a single element
array, with the object in that format, with its string representation
being the message.
If an element of the ``errors`` array is not in the format, then
it's converted to the format, with its string representation being
the message.
The input object is not changed, a copy is made if needed.
:return: the given ``data`` formatted to the correct shape, a copy
is made and returned if any fix up was needed.
:rtype: dict | [
"Given",
"a",
"possible",
"GraphQL",
"error",
"payload",
"make",
"sure",
"it",
"s",
"in",
"shape",
"."
] | 684afb059c93f142150043cafac09b7fd52bfa27 | https://github.com/profusion/sgqlc/blob/684afb059c93f142150043cafac09b7fd52bfa27/sgqlc/endpoint/base.py#L104-L163 | train |
profusion/sgqlc | sgqlc/endpoint/base.py | BaseEndpoint.snippet | def snippet(code, locations, sep=' | ', colmark=('-', '^'), context=5):
'''Given a code and list of locations, convert to snippet lines.
return will include line number, a separator (``sep``), then
line contents.
At most ``context`` lines are shown before each location line.
After each location line, the column is marked using
``colmark``. The first character is repeated up to column, the
second character is used only once.
:return: list of lines of sources or column markups.
:rtype: list
'''
if not locations:
return []
lines = code.split('\n')
offset = int(len(lines) / 10) + 1
linenofmt = '%{}d'.format(offset)
s = []
for loc in locations:
line = max(0, loc.get('line', 1) - 1)
column = max(0, loc.get('column', 1) - 1)
start_line = max(0, line - context)
for i, ln in enumerate(lines[start_line:line + 1], start_line):
s.append('{}{}{}'.format(linenofmt % i, sep, ln))
s.append('{}{}{}'.format(' ' * (offset + len(sep)),
colmark[0] * column,
colmark[1]))
return s | python | def snippet(code, locations, sep=' | ', colmark=('-', '^'), context=5):
'''Given a code and list of locations, convert to snippet lines.
return will include line number, a separator (``sep``), then
line contents.
At most ``context`` lines are shown before each location line.
After each location line, the column is marked using
``colmark``. The first character is repeated up to column, the
second character is used only once.
:return: list of lines of sources or column markups.
:rtype: list
'''
if not locations:
return []
lines = code.split('\n')
offset = int(len(lines) / 10) + 1
linenofmt = '%{}d'.format(offset)
s = []
for loc in locations:
line = max(0, loc.get('line', 1) - 1)
column = max(0, loc.get('column', 1) - 1)
start_line = max(0, line - context)
for i, ln in enumerate(lines[start_line:line + 1], start_line):
s.append('{}{}{}'.format(linenofmt % i, sep, ln))
s.append('{}{}{}'.format(' ' * (offset + len(sep)),
colmark[0] * column,
colmark[1]))
return s | [
"def",
"snippet",
"(",
"code",
",",
"locations",
",",
"sep",
"=",
"' | '",
",",
"colmark",
"=",
"(",
"'-'",
",",
"'^'",
")",
",",
"context",
"=",
"5",
")",
":",
"if",
"not",
"locations",
":",
"return",
"[",
"]",
"lines",
"=",
"code",
".",
"split"... | Given a code and list of locations, convert to snippet lines.
return will include line number, a separator (``sep``), then
line contents.
At most ``context`` lines are shown before each location line.
After each location line, the column is marked using
``colmark``. The first character is repeated up to column, the
second character is used only once.
:return: list of lines of sources or column markups.
:rtype: list | [
"Given",
"a",
"code",
"and",
"list",
"of",
"locations",
"convert",
"to",
"snippet",
"lines",
"."
] | 684afb059c93f142150043cafac09b7fd52bfa27 | https://github.com/profusion/sgqlc/blob/684afb059c93f142150043cafac09b7fd52bfa27/sgqlc/endpoint/base.py#L206-L236 | train |
profusion/sgqlc | sgqlc/types/__init__.py | _create_non_null_wrapper | def _create_non_null_wrapper(name, t):
'creates type wrapper for non-null of given type'
def __new__(cls, json_data, selection_list=None):
if json_data is None:
raise ValueError(name + ' received null value')
return t(json_data, selection_list)
def __to_graphql_input__(value, indent=0, indent_string=' '):
return t.__to_graphql_input__(value, indent, indent_string)
return type(name, (t,), {
'__new__': __new__,
'_%s__auto_register' % name: False,
'__to_graphql_input__': __to_graphql_input__,
}) | python | def _create_non_null_wrapper(name, t):
'creates type wrapper for non-null of given type'
def __new__(cls, json_data, selection_list=None):
if json_data is None:
raise ValueError(name + ' received null value')
return t(json_data, selection_list)
def __to_graphql_input__(value, indent=0, indent_string=' '):
return t.__to_graphql_input__(value, indent, indent_string)
return type(name, (t,), {
'__new__': __new__,
'_%s__auto_register' % name: False,
'__to_graphql_input__': __to_graphql_input__,
}) | [
"def",
"_create_non_null_wrapper",
"(",
"name",
",",
"t",
")",
":",
"'creates type wrapper for non-null of given type'",
"def",
"__new__",
"(",
"cls",
",",
"json_data",
",",
"selection_list",
"=",
"None",
")",
":",
"if",
"json_data",
"is",
"None",
":",
"raise",
... | creates type wrapper for non-null of given type | [
"creates",
"type",
"wrapper",
"for",
"non",
"-",
"null",
"of",
"given",
"type"
] | 684afb059c93f142150043cafac09b7fd52bfa27 | https://github.com/profusion/sgqlc/blob/684afb059c93f142150043cafac09b7fd52bfa27/sgqlc/types/__init__.py#L869-L883 | train |
profusion/sgqlc | sgqlc/types/__init__.py | _create_list_of_wrapper | def _create_list_of_wrapper(name, t):
'creates type wrapper for list of given type'
def __new__(cls, json_data, selection_list=None):
if json_data is None:
return None
return [t(v, selection_list) for v in json_data]
def __to_graphql_input__(value, indent=0, indent_string=' '):
r = []
for v in value:
r.append(t.__to_graphql_input__(v, indent, indent_string))
return '[' + ', '.join(r) + ']'
def __to_json_value__(value):
if value is None:
return None
return [t.__to_json_value__(v) for v in value]
return type(name, (t,), {
'__new__': __new__,
'_%s__auto_register' % name: False,
'__to_graphql_input__': __to_graphql_input__,
'__to_json_value__': __to_json_value__,
}) | python | def _create_list_of_wrapper(name, t):
'creates type wrapper for list of given type'
def __new__(cls, json_data, selection_list=None):
if json_data is None:
return None
return [t(v, selection_list) for v in json_data]
def __to_graphql_input__(value, indent=0, indent_string=' '):
r = []
for v in value:
r.append(t.__to_graphql_input__(v, indent, indent_string))
return '[' + ', '.join(r) + ']'
def __to_json_value__(value):
if value is None:
return None
return [t.__to_json_value__(v) for v in value]
return type(name, (t,), {
'__new__': __new__,
'_%s__auto_register' % name: False,
'__to_graphql_input__': __to_graphql_input__,
'__to_json_value__': __to_json_value__,
}) | [
"def",
"_create_list_of_wrapper",
"(",
"name",
",",
"t",
")",
":",
"'creates type wrapper for list of given type'",
"def",
"__new__",
"(",
"cls",
",",
"json_data",
",",
"selection_list",
"=",
"None",
")",
":",
"if",
"json_data",
"is",
"None",
":",
"return",
"Non... | creates type wrapper for list of given type | [
"creates",
"type",
"wrapper",
"for",
"list",
"of",
"given",
"type"
] | 684afb059c93f142150043cafac09b7fd52bfa27 | https://github.com/profusion/sgqlc/blob/684afb059c93f142150043cafac09b7fd52bfa27/sgqlc/types/__init__.py#L886-L909 | train |
profusion/sgqlc | sgqlc/endpoint/http.py | add_query_to_url | def add_query_to_url(url, extra_query):
'''Adds an extra query to URL, returning the new URL.
Extra query may be a dict or a list as returned by
:func:`urllib.parse.parse_qsl()` and :func:`urllib.parse.parse_qs()`.
'''
split = urllib.parse.urlsplit(url)
merged_query = urllib.parse.parse_qsl(split.query)
if isinstance(extra_query, dict):
for k, v in extra_query.items():
if not isinstance(v, (tuple, list)):
merged_query.append((k, v))
else:
for cv in v:
merged_query.append((k, cv))
else:
merged_query.extend(extra_query)
merged_split = urllib.parse.SplitResult(
split.scheme,
split.netloc,
split.path,
urllib.parse.urlencode(merged_query),
split.fragment,
)
return merged_split.geturl() | python | def add_query_to_url(url, extra_query):
'''Adds an extra query to URL, returning the new URL.
Extra query may be a dict or a list as returned by
:func:`urllib.parse.parse_qsl()` and :func:`urllib.parse.parse_qs()`.
'''
split = urllib.parse.urlsplit(url)
merged_query = urllib.parse.parse_qsl(split.query)
if isinstance(extra_query, dict):
for k, v in extra_query.items():
if not isinstance(v, (tuple, list)):
merged_query.append((k, v))
else:
for cv in v:
merged_query.append((k, cv))
else:
merged_query.extend(extra_query)
merged_split = urllib.parse.SplitResult(
split.scheme,
split.netloc,
split.path,
urllib.parse.urlencode(merged_query),
split.fragment,
)
return merged_split.geturl() | [
"def",
"add_query_to_url",
"(",
"url",
",",
"extra_query",
")",
":",
"split",
"=",
"urllib",
".",
"parse",
".",
"urlsplit",
"(",
"url",
")",
"merged_query",
"=",
"urllib",
".",
"parse",
".",
"parse_qsl",
"(",
"split",
".",
"query",
")",
"if",
"isinstance... | Adds an extra query to URL, returning the new URL.
Extra query may be a dict or a list as returned by
:func:`urllib.parse.parse_qsl()` and :func:`urllib.parse.parse_qs()`. | [
"Adds",
"an",
"extra",
"query",
"to",
"URL",
"returning",
"the",
"new",
"URL",
"."
] | 684afb059c93f142150043cafac09b7fd52bfa27 | https://github.com/profusion/sgqlc/blob/684afb059c93f142150043cafac09b7fd52bfa27/sgqlc/endpoint/http.py#L33-L59 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.