cache = {}

@wraps(f)

def wrapper(*args, **kwargs):

key = tuple(args) + tuple(entry for entry in sorted(kwargs.items()))

if key in cache:

return cache[key]

else:

val = f(*args, **kwargs)

cache[key] = val

return val

"""

def __init__(self, func):

self._func = func

self._attr_name = func.__name__

def __get__(self, instance, owner):

if instance is None:

return self

else:

val = self._func(instance)

instance.__dict__[self._attr_name] = val

paragraph = []

for line in s.splitlines():

line = line.strip()

if line == '':

if paragraph:

yield "\n".join(paragraph)

del paragraph[:]

else:

paragraph.append(line)

if paragraph:

assert isinstance(stone_fq_name, six.text_type), repr(stone_fq_name)

assert max_parts > 0, "max_parts must be positive"

parts = stone_fq_name.split('.')

if len(parts) > max_parts:

raise ValueError('Malformed Stone reference: %s' % stone_fq_name)

else:

filler = (None,) * (max_parts - len(parts))

('&', '&'),

('<', '&lt;'),

('>', '&gt;'),

# sanitize &, <, > characters

for char, code in _JAVADOC_REPLACEMENT_CHARS:

doc = doc.replace(char, code)

if not values:

return None

elif len(values) == 1:

return values[0]

elif len(values) == 2:

return '%s %s %s' % (values[0], conjunction, values[1])

else:

"""Return list of (tag, data_type) pairs.

assert isinstance(data_type, DataType), repr(data_type)

ancestors = []

while data_type is not None:

parent_type = data_type.parent_type

tag = None

if parent_type is not None and parent_type.has_enumerated_subtypes():

for field in parent_type.get_enumerated_subtypes():

if field.data_type is data_type:

tag = field.name

break

else:

assert False, "Type %s not found in subtypes of ancestor %s" % (data_type.name,

parent_type.name)

ancestors.append((tag, data_type))

data_type = parent_type

ancestors.reverse()

"""

assert isinstance(data_type, DataType), repr(data_type)

if not data_type.has_enumerated_subtypes():

return []

subtypes = []

def add_subtype(data_type):

subtypes.append(data_type)

if data_type.has_enumerated_subtypes():

for subtype in data_type.get_enumerated_subtypes():

add_subtype(subtype.data_type)

add_subtype(data_type)

result = []

for subtype in subtypes:

tag = '.'.join(name for name, _ in get_ancestors(subtype) if name)

result.append((tag, subtype))

assert isinstance(data_type, DataType), repr(data_type)

while True:

if allow_data_structures and is_list_type(data_type):

data_type = data_type.data_type

elif allow_data_structures and is_map_type(data_type):

data_type = data_type.value_data_type

elif is_nullable_type(data_type):

data_type = data_type.data_type

else:

break

if len(value_fields_subset) > 0:

method_suffix = 'And%s' % _capwords(value_fields_subset[0].name)

else:

method_suffix = ''

"""

def __init__(self, fq_name, generics=()):

assert isinstance(fq_name, six.text_type), repr(fq_name)

assert isinstance(generics, Sequence), repr(generics)

self._fq_name = fq_name

self._generics = generics

for g in generics:

assert isinstance(g, (JavaClass, six.text_type)), repr(generics)

if isinstance(g, six.text_type):

assert '.' not in g, repr(generics)

package_parts = fq_name.split('.')

# Handle nested classes, like:

#

# com.foo.Bar.Wop

#

# name => Wop

# package => com.foo

# static_name => Bar.Wop

# import_name => com.foo.Bar

#

self._name = package_parts[-1]

for i, part in enumerate(package_parts):

is_last = i == len(package_parts) - 1

is_class_name = (part and part[0].isupper())

if is_last or is_class_name:

self._package = '.'.join(package_parts[:i])

self._static_name = '.'.join(package_parts[i:])

self._import_name = '.'.join(package_parts[:i+1])

break

@classmethod

def from_str(cls, val):

"""

matcher = re.match(r'^(?P<fq_name>[^< ]+)(?:<(?P<generics>.*)>)?$', val)

if matcher is None:

raise ValueError("Malformed Java class: %s" % val)

fq_name = matcher.group('fq_name')

generics_group = matcher.group('generics')

generics = []

if generics_group is not None:

for gtype in generics_group.split(','):

gtype = gtype.strip()

if not gtype:

raise ValueError("Malformed Java class: %s" % val)

if '.' in gtype:

generics.append(cls.from_str(gtype))

else:

generics.append(gtype)

return JavaClass(fq_name, generics=generics)

@property

def fq(self):

"""

return self._fq_name

@property

def name(self):

"""

return self._name

@property

def name_with_generics(self):

if self._generics and all('.' in g for g in self._generics):

return '%s<%s>' % (self._name, ', '.join(self._generics))

else:

return self._name

def resolved_name(self, current_class, imports, generics=False):

"""

resolved = self._resolved_name(current_class, imports)

if generics and self._generics:

resolved_generics = ', '.join(

g.resolved_name(current_class, imports, generics) if isinstance(g, JavaClass) else g

for g in self._generics

)

return '%s<%s>' % (resolved, resolved_generics)

else:

return resolved

def _resolved_name(self, current_class, imports):

# no package, so just return the name

if not self._package:

return self._name

assert isinstance(current_class, JavaClass), repr(current_class)

assert imports is not None

# inner class? (e.g. com.foo.CommitInfo.Builder)

if self._fq_name.startswith(current_class._fq_name + '.'):

return self._fq_name[len(current_class._fq_name) + 1:]

# package-local class? we don't need to import these

if self._package == current_class.package:

return self._static_name

# check if we already imported this name into our current context

if self.import_class in imports:

return self._static_name

# last resort, display fully-qualified name

return self._fq_name

@property

def package(self):

"""

return self._package

@property

def is_nested(self):

"""

return self._static_name != self._name

@property

def import_class(self):

"""

return JavaClass(self._import_name)

def __repr__(self):

return '%s(%s)' % (type(self), str(self))

def __str__(self):

if self._generics:

return '%s<%s>' % (self._fq_name, ', '.join(str(g) for g in self._generics))

else:

return self._fq_name

def __hash__(self):

return hash(self._fq_name)

def __ne__(self, other):

return not self.__eq__(other)

def __eq__(self, other):

if isinstance(other, JavaClass):

return self._fq_name == other._fq_name

return False

def __lt__(self, other):

assert isinstance(other, type(self)), repr(other)

def __init__(self, rank, name, modifier):

self._rank = rank

self._name = name

self._modifier = modifier

@property

def name(self):

return self._name

@property

def is_visible(self):

return self._modifier is not None

@property

def modifier(self):

if not self.is_visible:

raise ValueError("Not visible")

return self._modifier

@classmethod

def from_name(cls, name):

for value in cls._VALUES:

if value.name == name:

return value

raise ValueError("Unrecognized name: %s" % name)

def __repr__(self):

return self._name

def __hash__(self):

return self._rank

def __ne__(self, other):

return not self.__eq__(other)

def __eq__(self, other):

if isinstance(other, type(self)):

return self._rank == other._rank

return False

def __lt__(self, other):

assert isinstance(other, type(self)), repr(other)

cmdline_parser = _CMDLINE_PARSER

def generate(self, api):

"""

generator = JavaCodeGenerationInstance(self, api)

if self.args.data_types_only:

assert self.args.javadoc_refs is None, "Cannot specify --javadoc-refs with --data-types-only"

generator.generate_data_types()

else:

def __init__(self, current_class, j):

assert isinstance(current_class, JavaClass), repr(current_class)

assert isinstance(j, JavaApi), repr(j)

self._class = current_class

self._j = j

self._imports = set()

@property

def imports(self):

return frozenset(self._imports)

def add_imports(self, *imports):

"""

assert all(isinstance(i, (six.text_type, JavaClass)) for i in imports), repr(imports)

def convert(val):

if isinstance(val, JavaClass):

return val

elif isinstance(val, six.string_types):

return JavaClass(val)

else:

raise AssertionError(repr(type(val)))

# convert all imports to JavaClass instances

imports = [convert(i) for i in imports]

# remove imports that are missing package (e.g. long, Integer,

# etc) and imports from java.lang

imports = [

i for i in imports

if i.package and i.package != 'java.lang'

]

current_class_prefix = self._class.fq + '.'

existing_names = {i.name: i for i in self._imports}

# avoid issues where we import a class with the same name as us

existing_names[self._class.name] = self._class

for import_ in imports:

# resolve nested classes to their root containing class

import_ = import_.import_class

# already imported or local name (not fully qualified)

if import_ in self._imports or not import_.package:

continue

# ignore nested classes inside our current class

if import_ == self._class:

continue

# is this import in our existing names? make sure we choose the most "valid" import

# between the two:

if import_.name in existing_names:

# we always prefer package-local imports, otherwise we can't determine at name

# resolution time whether a package-local class needs to be fully-qualified or

# not. This means we essentially block all imports that clash with package-local

# class names.

if import_.package == self._class.package:

existing_import = existing_names[import_.name]

self._imports.remove(existing_import)

existing_names[import_.name] = import_

self._imports.add(import_)

else:

# leave the existing import alone

pass

else:

# new import

existing_names[import_.name] = import_

self._imports.add(import_)

def add_imports_for_namespace(self, namespace):

assert isinstance(namespace, ApiNamespace), repr(namespace)

self.add_imports(

'com.dropbox.core.DbxException',

'com.dropbox.core.DbxWrappedException',

'com.dropbox.core.http.HttpRequestor',

'com.dropbox.core.v2.DbxRawClientV2',

'java.util.HashMap',

'java.util.Map',

)

for route in namespace.routes:

self.add_imports_for_route(route)

def add_imports_for_route(self, route):

assert isinstance(route, ApiRoute), repr(route)

j = self._j

self._add_imports_for_data_type(route.arg_data_type)

self._add_imports_for_data_type(route.result_data_type)

self._add_imports_for_data_type_exception(route.error_data_type)

if j.has_builder(route) and j.has_arg(route) and j.has_builder(route.arg_data_type):

self._add_imports_for_data_type_builder(route.arg_data_type)

if is_struct_type(route.arg_data_type):

if j.has_builder(route):

fields = route.arg_data_type.all_required_fields

else:

fields = route.arg_data_type.all_fields

for field in fields:

self.add_imports_for_field(field)

if j.request_style(route) == 'upload':

self.add_imports('com.dropbox.core.DbxUploader')

if j.has_builder(route):

self.add_imports('com.dropbox.core.v2.DbxUploadStyleBuilder')

elif j.request_style(route) == 'download':

self.add_imports(

'com.dropbox.core.DbxDownloader',

'com.dropbox.core.v2.DbxDownloadStyleBuilder',

'java.util.Collections',

'java.util.List',

'java.util.Map',

)

def add_imports_for_route_builder(self, route):

assert isinstance(route, ApiRoute), repr(route)

j = self._j

assert j.has_builder(route), repr(route)

if j.has_arg(route) and j.has_builder(route.arg_data_type):

self._add_imports_for_data_type_builder(route.arg_data_type)

self._add_imports_for_data_type(route.result_data_type)

self._add_imports_for_data_type_exception(route.error_data_type)

namespace = j.route_namespace(route)

route_auth = j.auth_style(route) if j.auth_style(route) != 'noauth' else 'user'

self.add_imports(

j.java_class(namespace),

'com.dropbox.core.DbxException',

)

for field in route.arg_data_type.all_optional_fields:

self.add_imports_for_field(field)

if j.request_style(route) == 'download':

self.add_imports(

'com.dropbox.core.v2.DbxDownloadStyleBuilder',

'com.dropbox.core.DbxDownloader',

)

elif j.request_style(route) == 'upload':

self.add_imports('com.dropbox.core.v2.DbxUploadStyleBuilder')

def add_imports_for_route_uploader(self, route):

self.add_imports(

'com.dropbox.core.DbxWrappedException',

'com.dropbox.core.DbxUploader',

'com.dropbox.core.http.HttpRequestor',

'java.io.IOException',

)

self._add_imports_for_data_type(route.result_data_type)

self._add_imports_for_data_type_exception(route.error_data_type)

def add_imports_for_data_type(self, data_type, include_serialization=True):

assert isinstance(data_type, DataType), repr(data_type)

assert is_user_defined_type(data_type), repr(data_type)

j = self._j

# for hash code computation

if data_type.fields or (is_union_type(data_type) and not j.is_enum(data_type)):

self.add_imports('java.util.Arrays')

self._add_imports_for_data_type(data_type)

if include_serialization:

self._add_imports_for_data_type_serializers(data_type)

for field in data_type.all_fields:

self.add_imports_for_field(field)

# for regex pattern validation

if is_string_type(field.data_type) and field.data_type.pattern is not None:

self.add_imports('java.util.regex.Pattern')

# check if we need to import parent type

if is_struct_type(data_type) and data_type.parent_type:

self._add_imports_for_data_type(data_type.parent_type)

def add_imports_for_exception_type(self, data_type):

j = self._j

self.add_imports(

'com.dropbox.core.DbxApiException',

'com.dropbox.core.LocalizedText',

j.java_class(data_type),

)

def add_imports_for_field(self, field):

self._add_imports_for_data_type(field.data_type)

def _add_imports_for_data_type(self, data_type):

j = self._j

if is_user_defined_type(data_type):

self.add_imports(j.java_class(data_type))

else:

java_type = _TYPE_MAP_UNBOXED.get(data_type.name)

if java_type and '.' in java_type:

self.add_imports(java_type)

if is_list_type(data_type) or is_nullable_type(data_type):

self._add_imports_for_data_type(data_type.data_type)

elif is_map_type(data_type):

self._add_imports_for_data_type(data_type.value_data_type)

elif is_timestamp_type(data_type):

self.add_imports('com.dropbox.core.util.LangUtil')

def _add_imports_for_data_type_builder(self, data_type):

assert isinstance(data_type, DataType), repr(data_type)

j = self._j

self.add_imports(j.builder_class(data_type))

def _add_imports_for_data_type_exception(self, data_type):

j = self._j

if is_void_type(data_type):

self.add_imports('com.dropbox.core.DbxApiException')

else:

self.add_imports(

j.java_class(data_type),

j.exception_class(data_type),

)

def _add_imports_for_data_type_serializers(self, data_type):

self.add_imports(

'java.io.IOException',

'com.fasterxml.jackson.core.JsonGenerationException',

'com.fasterxml.jackson.core.JsonGenerator',

'com.fasterxml.jackson.core.JsonParseException',

'com.fasterxml.jackson.core.JsonParser',

'com.fasterxml.jackson.core.JsonToken',

'com.dropbox.core.stone.StoneSerializers',

)

if is_struct_type(data_type):

self.add_imports('com.dropbox.core.stone.StructSerializer')

elif is_union_type(data_type):

self.add_imports('com.dropbox.core.stone.UnionSerializer')

def __repr__(self):

def __init__(self, g, j, refs, java_class, stone_element=None, package_doc=None):

assert isinstance(java_class, JavaClass), repr(java_class)

assert java_class.package, repr(java_class)

self.importer = JavaImporter(java_class, j)

self._g = g

self._j = j

self._refs = refs

self._class = java_class

self._stone_element = stone_element

self._package_doc = package_doc

if package_doc:

assert java_class.name == 'package-info', "Only package-info.java files can contain package Javadoc"

def _mkdirs(self, path):

if not os.path.isdir(path):

self._g.logger.info('Creating directory %s', path)

os.makedirs(path)

def __enter__(self):

components = self._class.import_class.fq.split('.')

path = os.path.join(*components)

self._mkdirs(os.path.dirname(path))

self._enter_ctx = self._g.output_to_relative_path(path + '.java')

self._enter_ctx.__enter__()

self._emit_header()

if self._package_doc:

self.javadoc(self._package_doc)

self.out('package %s;', self._class.package)

self.out('')

return self

def __exit__(self, exc_type, exc_value, traceback):

ret = self._enter_ctx.__exit__(exc_type, exc_value, traceback)

self._enter_ctx = None

return ret

def fmt(self, fmt_str, *args, **kwargs):

assert isinstance(fmt_str, six.text_type), repr(fmt_str)

generics = kwargs.get('generics', True)

# resolve JavaClass to appropriate names based on our current imports

resolved_args = tuple(

self.resolved_class(a, generics=generics) if isinstance(a, JavaClass) else a

for a in args

)

return fmt_str % resolved_args

def out(self, fmt_str, *args, **kwargs):

self._g.emit(self.fmt(fmt_str, *args), **kwargs)

def block(self, fmt_str, *args, **kwargs):

return self._g.block(self.fmt(fmt_str, *args).strip(), **kwargs)

@contextmanager

def conditional_block(self, predicate, fmt_str, *args):

if predicate:

with self.block(fmt_str, *args):

yield

else:

yield

def class_block(self, element, visibility=Visibility.PUBLIC, parent_class=None):

assert isinstance(element, (JavaClass, StoneType)), repr(element)

assert visibility.is_visible, repr((element, visibility))

j = self._j

java_class = j.java_class(element) if isinstance(element, StoneType) else element

modifiers = [visibility.modifier]

class_type = 'class'

class_name = java_class.name_with_generics

inheritance = parent_class

if java_class.is_nested:

modifiers.append('static')

if isinstance(element, DataType):

data_type = element

if j.is_enum(data_type):

class_type = 'enum'

elif is_union_type(data_type):

modifiers.append('final')

elif is_struct_type(data_type) and data_type.parent_type:

assert parent_class is None, repr((data_type, parent_class))

inheritance = j.java_class(data_type.parent_type)

if inheritance:

return self.block('%s %s %s extends %s', ' '.join(modifiers), class_type, class_name, inheritance)

else:

return self.block('%s %s %s', ' '.join(modifiers), class_type, class_name)

def resolved_class(self, val, generics=True):

if isinstance(val, six.text_type):

val = JavaClass(val)

else:

assert isinstance(val, JavaClass), repr(val)

return val.resolved_name(self._class, self.importer.imports, generics=generics)

def _emit_header(self):

j = self._j

filenames = j.get_spec_filenames(self._stone_element) if self._stone_element else None

self.out('/* DO NOT EDIT */')

if filenames:

self.out('/* This file was generated from %s */' % ', '.join(filenames))

else:

self.out('/* This file was generated by Stone */')

self.out('')

def write_imports(self):

# start off will all imports, then group into categories

imports = self.importer.imports

# remove package-local imports

imports = {

import_ for import_ in imports