::::::::::::::::::    PRIVATE STUFF    :::::::::::::::::::::
164159
private Calendar impl_createService(Credential credentials) {
        return new Calendar.Builder(httpTransport, jsonFactory, credentials).setApplicationName(APPLICATION_NAME).build();
    }
1278976
def key_file_private(self):
        '''
        '''
        if not hasattr(self, '_key_file_private'):
            self.key_file_private = '~/.ssh/{key}'.format(key=self.key_name)
        return self._key_file_private
929501
def can_access(self, permission_name, view_name):
        """"""
        user = g.user
        if user.is_anonymous:
            return self.is_item_public(permission_name, view_name)
        return self._has_view_access(user, permission_name, view_name)
929313
def _get_private_room(self, invitees: List[User]):
        
        return self._client.create_room(
            None,
            invitees=[user.user_id for user in invitees],
            is_public=False,
        )
308237
def get_private_file(self):
        
        return PrivateFile(
            request=self.request,
            storage=self.get_storage(),
            relative_name=self.get_path()
        )
1000152
function() {
      var properties = {
        normal: [],
        relational: [],
        derived: []
      };
      var privateProps = this._private || {};
      var relations = _.result(this, 'relations') || {};
      var derived = _.result(this, 'derived') || {};

      var isEditable = function(value) {
        if (!_.isObject(value)) {
          return true;
        } else if (_.isArray(value)) {
          var result = true;
          _.each(value, function(i) {
            result = result && isEditable(i);
          });
          return result;
        } else {
          try {
            JSON.stringify(value);
            return true;
          } catch (ex) {
            return false;
          }
        }
      };

      _.each(this.attributes, function(value, key) {
        if (privateProps[key]) {
          return;
        }
        var prop;
        if (relations && relations[key]) {
          properties.relational.push({
            key: key,
            data: {
              isRelation: true,
              name: value.getDebugName()
            }
          });
        } else if (derived && derived[key]) {
          properties.derived.push({
            key: key,
            data: {
              isDerived: derived[key],
              value: value,
              displayValue: isEditable(value) ? JSON.stringify(value) : Object.prototype.toString.call(value)
            }
          });
        } else {
          prop = {
            key: key,
            data: {
              isEditable: isEditable(value),
              isEditing: false,
              isRemovable: true,
              value: value
            }
          };

          prop.data.displayValue = prop.data.isEditable ? JSON.stringify(value) : Object.prototype.toString.call(value);
          properties.normal.push(prop);
        }
      });

      properties.normal = _.sortBy(properties.normal, 'key');
      properties.relational = _.sortBy(properties.relational, 'key');
      properties.derived = _.sortBy(properties.derived, 'key');

      return properties;
    }
497272
def public(self) -> 'PrettyDir':
        """"""
        return PrettyDir(
            self.obj, [pattr for pattr in self.pattrs if not pattr.name.startswith('_')]
        )
155552
function exposeAttributes(collection) {
    function exposeModelAttributes(item) {
        // Make sure that relations are excluded
        return Object.assign(item, item.serialize({ shallow: true }));
    }
    if (collection) {
        if (collection.hasOwnProperty('length')) {
            return collection.map((item) => { return exposeModelAttributes(item); });
        }
        return exposeModelAttributes(collection);
    }
    return collection;
}
1160211
def userItem(self):
        """"""
        if self.ownerFolder is not None:
            url = "%s/users/%s/%s/items/%s" % (self.root.split('/items/')[0], self.owner,self.ownerFolder, self.id)
        else:
            url = "%s/users/%s/items/%s" % (self.root.split('/items/')[0], self.owner, self.id)
        return UserItem(url=url,
                        securityHandler=self._securityHandler,
                        proxy_url=self._proxy_url,
                        proxy_port=self._proxy_port)
64996
def delete_private
      # Iterate all children, and repeat recursively if a child itself has children, to delete all private data elements:
      children.each do |element|
        delete(element.tag) if element.tag.private?
        element.delete_private if element.children?
      end
    end
311611
def _apply_nested_privacy(self, data):
        
        kw = {
            'is_admin': self.is_admin,
            'drop_hidden': self.drop_hidden,
        }
        for key, val in data.items():
            if is_document(val):
                data[key] = apply_privacy(self.request)(result=val, **kw)
            elif isinstance(val, list) and val and is_document(val[0]):
                data[key] = [apply_privacy(self.request)(result=doc, **kw)
                             for doc in val]
        return data
819849
def owners(self):
        ''''''
        return [o.strip() for o in self.owner.split(self.OWNER_ID_SEPARATOR)]
1273066
def public(self, *args, **kwargs):
        
        kwargs['public'] = True
        return self.filter(*args, **kwargs)
224481
def dump_private_keys_or_addrs_chooser(wallet_obj):
    '''
    
    '''

    if wallet_obj.private_key:
        puts('Which private keys and addresses do you want?')
    else:
        puts('Which addresses do you want?')
    with indent(2):
        puts(colored.cyan('1: Active - have funds to spend'))
        puts(colored.cyan('2: Spent - no funds to spend (because they have been spent)'))
        puts(colored.cyan('3: Unused - no funds to spend (because the address has never been used)'))
        puts(colored.cyan('0: All (works offline) - regardless of whether they have funds to spend (super advanced users only)'))
        puts(colored.cyan('\nb: Go Back\n'))
    choice = choice_prompt(
            user_prompt=DEFAULT_PROMPT,
            acceptable_responses=[0, 1, 2, 3],
            default_input='1',
            show_default=True,
            quit_ok=True,
            )

    if choice is False:
        return

    if choice == '1':
        return dump_selected_keys_or_addrs(wallet_obj=wallet_obj, zero_balance=False, used=True)
    elif choice == '2':
        return dump_selected_keys_or_addrs(wallet_obj=wallet_obj, zero_balance=True, used=True)
    elif choice == '3':
        return dump_selected_keys_or_addrs(wallet_obj=wallet_obj, zero_balance=None, used=False)
    elif choice == '0':
        return dump_all_keys_or_addrs(wallet_obj=wallet_obj)
918526
def __hide_or_show_root_items(self, item):
        
        for _it in self.get_top_level_items():
            _it.setHidden(_it is not item and not self.show_all_files)
1100925
def exportable_keys(self):
    
    keys = collections.defaultdict(list)
    for tup in self._tuples:
      for key, private in tup._keys_and_privacy().items():
        keys[key].append(private)
    return [k for k, ps in keys.items() if not any(ps)]
1333405
def secret(self, s):
        
        s = parseable_str(s)
        for f in [self.private_key, self.hierarchical_key]:
            v = f(s)
            if v:
                return v