text:
import Ember from "ember";
const { Controller, computed } = Ember;
const { bool, readOnly, and } = computed;

export default Controller.extend({
  known: bool('model.map.source'),

  url: computed('model.map.source', 'model.map.line', 'known', function() {
    let source = this.get('model.map.source');
    if (this.get('known')) {
      return source + ':' + this.get('model.map.line');
    } else {
      return 'Unkown source';
    }
  }),

  adapter: readOnly('port.adapter'),

  isClickable: and('known', 'adapter.canOpenResource')
});

redpajama_set_name: RedPajamaGithub


text:
resume
======

Personal Resume & Extended Resume


text:
[![Build Status](https://travis-ci.org/jobscore/ruby-image.svg?branch=master)](https://travis-ci.org/jobscore/ruby-image)

# ruby-image
Packer template and files for Dev/Test ruby image


text:
<?php
/*
The comments page for Bones
*/

// Do not delete these lines
  if (!empty($_SERVER['SCRIPT_FILENAME']) && 'comments.php' == basename($_SERVER['SCRIPT_FILENAME']))
    die ('Please do not load this page directly. Thanks!');

  if ( post_password_required() ) { ?>

<?php _e("This post is password protected. Enter the password to view comments.","bonestheme"); ?>

  <?php
    return;
  }
?>

<?php if ( have_comments() ) : ?>
	<?php if ( ! empty($comments_by_type['comment']) ) : ?>

<?php comments_number('' . __("No","bonestheme") . ' ' . __("Responses","bonestheme") . '', '' . __("One","bonestheme") . ' ' . __("Response","bonestheme") . '', '% ' . __("Responses","bonestheme") );?> <?php _e("to","bonestheme"); ?> “<?php the_title(); ?>”

<?php previous_comments_link( __("Older comments","bonestheme") ) ?>

<?php next_comments_link( __("Newer comments","bonestheme") ) ?>

		<?php wp_list_comments('type=comment&callback=bones_comments'); ?>

	<?php endif; ?>

	<?php if ( ! empty($comments_by_type['pings']) ) : ?>

Trackbacks/Pingbacks

			<?php wp_list_comments('type=pings&callback=list_pings'); ?>

	<?php endif; ?>

<?php previous_comments_link( __("Older comments","bonestheme") ) ?>

<?php next_comments_link( __("Newer comments","bonestheme") ) ?>

	<?php else : // this is displayed if there are no comments so far ?>

	<?php if ( comments_open() ) : ?>

	<?php else : // comments are closed
	?>

	<?php
		$suppress_comments_message = of_get_option('suppress_comments_message');

		if (is_page() && $suppress_comments_message) :
	?>

		<?php else : ?>

<?php _e("Comments are closed","bonestheme"); ?>.

		<?php endif; ?>

	<?php endif; ?>

<?php endif; ?>

<?php if ( comments_open() ) : ?>

<?php comment_form_title( __("Leave a Reply","bonestheme"), __("Leave a Reply to","bonestheme") . ' %s' ); ?>

<?php cancel_comment_reply_link( __("Cancel","bonestheme") ); ?>

	<?php if ( get_option('comment_registration') && !is_user_logged_in() ) : ?>

<?php _e("You must be","bonestheme"); ?> <a href="<?php echo wp_login_url( get_permalink() ); ?>"><?php _e("logged in","bonestheme"); ?> <?php _e("to post a comment","bonestheme"); ?>.

	<?php else : ?>

	<form action="<?php echo get_option('siteurl'); ?>/wp-comments-post.php" method="post" class="form-vertical" id="commentform">

	<?php if ( is_user_logged_in() ) : ?>

<?php _e("Logged in as","bonestheme"); ?> <a href="<?php echo get_option('siteurl'); ?>/wp-admin/profile.php"><?php echo $user_identity; ?>. <a href="<?php echo wp_logout_url(get_permalink()); ?>" title="<?php _e("Log out of this account","bonestheme"); ?>"><?php _e("Log out","bonestheme"); ?> »

	<?php else : ?>

			  <?php _e("Name","bonestheme"); ?> <?php if ($req) echo "(required)"; ?>

			  	<input type="text" name="author" id="author" value="<?php echo esc_attr($comment_author); ?>" placeholder="<?php _e("Your Name","bonestheme"); ?>" tabindex="1" <?php if ($req) echo "aria-required='true'"; ?> />

			  <?php _e("Mail","bonestheme"); ?> <?php if ($req) echo "(required)"; ?>

			  	<input type="email" name="email" id="email" value="<?php echo esc_attr($comment_author_email); ?>" placeholder="<?php _e("Your Email","bonestheme"); ?>" tabindex="2" <?php if ($req) echo "aria-required='true'"; ?> />
			  	(<?php _e("will not be published","bonestheme"); ?>)

			  <?php _e("Website","bonestheme"); ?>

			  <input type="url" name="url" id="url" value="<?php echo esc_attr($comment_author_url); ?>" placeholder="<?php _e("Your Website","bonestheme"); ?>" tabindex="3" />

	<?php endif; ?>

			<textarea name="comment" id="comment" placeholder="<?php _e("Your Comment Here…","bonestheme"); ?>" tabindex="4"></textarea>

	  <input class="btn btn-primary" name="submit" type="submit" id="submit" tabindex="5" value="<?php _e("Submit Comment","bonestheme"); ?>" />
	  <?php comment_id_fields(); ?>

	<?php
		//comment_form();
		do_action('comment_form()', $post->ID);

	?>

	</form>

	<?php endif; // If registration required and not logged in ?>

<?php endif; // if you delete this the sky will fall on your head ?>


text:
{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
{-| Module    : QTextBlockGroup_h.hs
    Copyright : (c) David Harley 2010
    Project   : qtHaskell
    Version   : 1.1.4
    Modified  : 2010-09-02 17:02:19

    Warning   : this file is machine generated - do not modify.
--}
-----------------------------------------------------------------------------

module Qtc.Gui.QTextBlockGroup_h where

import Qtc.Enums.Base

import Qtc.Classes.Base
import Qtc.Classes.Qccs_h
import Qtc.Classes.Core_h
import Qtc.ClassTypes.Core
import Qth.ClassTypes.Core
import Qtc.Classes.Gui_h
import Qtc.ClassTypes.Gui
import Foreign.Marshal.Array

instance QunSetUserMethod (QTextBlockGroup ()) where
 unSetUserMethod qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    qtc_QTextBlockGroup_unSetUserMethod cobj_qobj (toCInt 0) (toCInt evid)

foreign import ccall "qtc_QTextBlockGroup_unSetUserMethod" qtc_QTextBlockGroup_unSetUserMethod :: Ptr (TQTextBlockGroup a) -> CInt -> CInt -> IO (CBool)

instance QunSetUserMethod (QTextBlockGroupSc a) where
 unSetUserMethod qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    qtc_QTextBlockGroup_unSetUserMethod cobj_qobj (toCInt 0) (toCInt evid)

instance QunSetUserMethodVariant (QTextBlockGroup ()) where
 unSetUserMethodVariant qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    qtc_QTextBlockGroup_unSetUserMethod cobj_qobj (toCInt 1) (toCInt evid)

instance QunSetUserMethodVariant (QTextBlockGroupSc a) where
 unSetUserMethodVariant qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    qtc_QTextBlockGroup_unSetUserMethod cobj_qobj (toCInt 1) (toCInt evid)

instance QunSetUserMethodVariantList (QTextBlockGroup ()) where
 unSetUserMethodVariantList qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    qtc_QTextBlockGroup_unSetUserMethod cobj_qobj (toCInt 2) (toCInt evid)

instance QunSetUserMethodVariantList (QTextBlockGroupSc a) where
 unSetUserMethodVariantList qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    qtc_QTextBlockGroup_unSetUserMethod cobj_qobj (toCInt 2) (toCInt evid)

instance QsetUserMethod (QTextBlockGroup ()) (QTextBlockGroup x0 -> IO ()) where
 setUserMethod _eobj _eid _handler
  = do
    funptr  <- wrapSetUserMethod_QTextBlockGroup setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetUserMethod_QTextBlockGroup_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      qtc_QTextBlockGroup_setUserMethod cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return ()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> IO ()
    setHandlerWrapper x0
      = do
        x0obj <- objectFromPtr_nf x0
        if (objectIsNull x0obj)
         then return ()
         else _handler x0obj

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

foreign import ccall "qtc_QTextBlockGroup_setUserMethod" qtc_QTextBlockGroup_setUserMethod :: Ptr (TQTextBlockGroup a) -> CInt -> Ptr (Ptr (TQTextBlockGroup x0) -> IO ()) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()

foreign import ccall "wrapper" wrapSetUserMethod_QTextBlockGroup :: (Ptr (TQTextBlockGroup x0) -> IO ()) -> IO (FunPtr (Ptr (TQTextBlockGroup x0) -> IO ()))

foreign import ccall "wrapper" wrapSetUserMethod_QTextBlockGroup_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))

instance QsetUserMethod (QTextBlockGroupSc a) (QTextBlockGroup x0 -> IO ()) where
 setUserMethod _eobj _eid _handler
  = do
    funptr  <- wrapSetUserMethod_QTextBlockGroup setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetUserMethod_QTextBlockGroup_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      qtc_QTextBlockGroup_setUserMethod cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return ()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> IO ()
    setHandlerWrapper x0
      = do
        x0obj <- objectFromPtr_nf x0
        if (objectIsNull x0obj)
         then return ()
         else _handler x0obj

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

instance QsetUserMethod (QTextBlockGroup ()) (QTextBlockGroup x0 -> QVariant () -> IO (QVariant ())) where
 setUserMethod _eobj _eid _handler
  = do
    funptr  <- wrapSetUserMethodVariant_QTextBlockGroup setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetUserMethodVariant_QTextBlockGroup_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      qtc_QTextBlockGroup_setUserMethodVariant cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return ()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
    setHandlerWrapper x0 x1
      = do
        x0obj <- objectFromPtr_nf x0
        x1obj <- objectFromPtr_nf x1
        rv <- if (objectIsNull x0obj)
               then return $ objectCast x0obj
               else _handler x0obj x1obj
        withObjectPtr rv $ \cobj_rv -> return cobj_rv

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

foreign import ccall "qtc_QTextBlockGroup_setUserMethodVariant" qtc_QTextBlockGroup_setUserMethodVariant :: Ptr (TQTextBlockGroup a) -> CInt -> Ptr (Ptr (TQTextBlockGroup x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()

foreign import ccall "wrapper" wrapSetUserMethodVariant_QTextBlockGroup :: (Ptr (TQTextBlockGroup x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))) -> IO (FunPtr (Ptr (TQTextBlockGroup x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))))

foreign import ccall "wrapper" wrapSetUserMethodVariant_QTextBlockGroup_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))

instance QsetUserMethod (QTextBlockGroupSc a) (QTextBlockGroup x0 -> QVariant () -> IO (QVariant ())) where
 setUserMethod _eobj _eid _handler
  = do
    funptr  <- wrapSetUserMethodVariant_QTextBlockGroup setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetUserMethodVariant_QTextBlockGroup_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      qtc_QTextBlockGroup_setUserMethodVariant cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return ()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
    setHandlerWrapper x0 x1
      = do
        x0obj <- objectFromPtr_nf x0
        x1obj <- objectFromPtr_nf x1
        rv <- if (objectIsNull x0obj)
               then return $ objectCast x0obj
               else _handler x0obj x1obj
        withObjectPtr rv $ \cobj_rv -> return cobj_rv

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

instance QunSetHandler (QTextBlockGroup ()) where
 unSetHandler qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    withCWString evid $ \cstr_evid ->
    qtc_QTextBlockGroup_unSetHandler cobj_qobj cstr_evid

foreign import ccall "qtc_QTextBlockGroup_unSetHandler" qtc_QTextBlockGroup_unSetHandler :: Ptr (TQTextBlockGroup a) -> CWString -> IO (CBool)

instance QunSetHandler (QTextBlockGroupSc a) where
 unSetHandler qobj evid
  = withBoolResult $
    withObjectPtr qobj $ \cobj_qobj ->
    withCWString evid $ \cstr_evid ->
    qtc_QTextBlockGroup_unSetHandler cobj_qobj cstr_evid

instance QsetHandler (QTextBlockGroup ()) (QTextBlockGroup x0 -> QTextBlock t1 -> IO ()) where
 setHandler _eobj _eid _handler
  = do
    funptr  <- wrapSetHandler_QTextBlockGroup1 setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetHandler_QTextBlockGroup1_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      withCWString _eid $ \cstr_eid ->
      qtc_QTextBlockGroup_setHandler1 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQTextBlock t1) -> IO ()
    setHandlerWrapper x0 x1
      = do x0obj <- qTextBlockGroupFromPtr x0
           x1obj <- objectFromPtr_nf x1
           if (objectIsNull x0obj)
            then return ()
            else _handler x0obj x1obj

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

foreign import ccall "qtc_QTextBlockGroup_setHandler1" qtc_QTextBlockGroup_setHandler1 :: Ptr (TQTextBlockGroup a) -> CWString -> Ptr (Ptr (TQTextBlockGroup x0) -> Ptr (TQTextBlock t1) -> IO ()) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()

foreign import ccall "wrapper" wrapSetHandler_QTextBlockGroup1 :: (Ptr (TQTextBlockGroup x0) -> Ptr (TQTextBlock t1) -> IO ()) -> IO (FunPtr (Ptr (TQTextBlockGroup x0) -> Ptr (TQTextBlock t1) -> IO ()))

foreign import ccall "wrapper" wrapSetHandler_QTextBlockGroup1_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))

instance QsetHandler (QTextBlockGroupSc a) (QTextBlockGroup x0 -> QTextBlock t1 -> IO ()) where
 setHandler _eobj _eid _handler
  = do
    funptr  <- wrapSetHandler_QTextBlockGroup1 setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetHandler_QTextBlockGroup1_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      withCWString _eid $ \cstr_eid ->
      qtc_QTextBlockGroup_setHandler1 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQTextBlock t1) -> IO ()
    setHandlerWrapper x0 x1
      = do x0obj <- qTextBlockGroupFromPtr x0
           x1obj <- objectFromPtr_nf x1
           if (objectIsNull x0obj)
            then return ()
            else _handler x0obj x1obj

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

instance QblockFormatChanged_h (QTextBlockGroup ()) ((QTextBlock t1)) where
 blockFormatChanged_h x0 (x1)
  = withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_blockFormatChanged cobj_x0 cobj_x1

foreign import ccall "qtc_QTextBlockGroup_blockFormatChanged" qtc_QTextBlockGroup_blockFormatChanged :: Ptr (TQTextBlockGroup a) -> Ptr (TQTextBlock t1) -> IO ()

instance QblockFormatChanged_h (QTextBlockGroupSc a) ((QTextBlock t1)) where
 blockFormatChanged_h x0 (x1)
  = withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_blockFormatChanged cobj_x0 cobj_x1

instance QblockInserted_h (QTextBlockGroup ()) ((QTextBlock t1)) where
 blockInserted_h x0 (x1)
  = withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_blockInserted cobj_x0 cobj_x1

foreign import ccall "qtc_QTextBlockGroup_blockInserted" qtc_QTextBlockGroup_blockInserted :: Ptr (TQTextBlockGroup a) -> Ptr (TQTextBlock t1) -> IO ()

instance QblockInserted_h (QTextBlockGroupSc a) ((QTextBlock t1)) where
 blockInserted_h x0 (x1)
  = withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_blockInserted cobj_x0 cobj_x1

instance QblockRemoved_h (QTextBlockGroup ()) ((QTextBlock t1)) where
 blockRemoved_h x0 (x1)
  = withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_blockRemoved cobj_x0 cobj_x1

foreign import ccall "qtc_QTextBlockGroup_blockRemoved" qtc_QTextBlockGroup_blockRemoved :: Ptr (TQTextBlockGroup a) -> Ptr (TQTextBlock t1) -> IO ()

instance QblockRemoved_h (QTextBlockGroupSc a) ((QTextBlock t1)) where
 blockRemoved_h x0 (x1)
  = withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_blockRemoved cobj_x0 cobj_x1

instance QsetHandler (QTextBlockGroup ()) (QTextBlockGroup x0 -> QEvent t1 -> IO (Bool)) where
 setHandler _eobj _eid _handler
  = do
    funptr  <- wrapSetHandler_QTextBlockGroup2 setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetHandler_QTextBlockGroup2_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      withCWString _eid $ \cstr_eid ->
      qtc_QTextBlockGroup_setHandler2 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQEvent t1) -> IO (CBool)
    setHandlerWrapper x0 x1
      = do x0obj <- qTextBlockGroupFromPtr x0
           x1obj <- objectFromPtr_nf x1
           let rv =
                if (objectIsNull x0obj)
                 then return False
                 else _handler x0obj x1obj
           rvf <- rv
           return (toCBool rvf)

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

foreign import ccall "qtc_QTextBlockGroup_setHandler2" qtc_QTextBlockGroup_setHandler2 :: Ptr (TQTextBlockGroup a) -> CWString -> Ptr (Ptr (TQTextBlockGroup x0) -> Ptr (TQEvent t1) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()

foreign import ccall "wrapper" wrapSetHandler_QTextBlockGroup2 :: (Ptr (TQTextBlockGroup x0) -> Ptr (TQEvent t1) -> IO (CBool)) -> IO (FunPtr (Ptr (TQTextBlockGroup x0) -> Ptr (TQEvent t1) -> IO (CBool)))

foreign import ccall "wrapper" wrapSetHandler_QTextBlockGroup2_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))

instance QsetHandler (QTextBlockGroupSc a) (QTextBlockGroup x0 -> QEvent t1 -> IO (Bool)) where
 setHandler _eobj _eid _handler
  = do
    funptr  <- wrapSetHandler_QTextBlockGroup2 setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetHandler_QTextBlockGroup2_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      withCWString _eid $ \cstr_eid ->
      qtc_QTextBlockGroup_setHandler2 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQEvent t1) -> IO (CBool)
    setHandlerWrapper x0 x1
      = do x0obj <- qTextBlockGroupFromPtr x0
           x1obj <- objectFromPtr_nf x1
           let rv =
                if (objectIsNull x0obj)
                 then return False
                 else _handler x0obj x1obj
           rvf <- rv
           return (toCBool rvf)

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

instance Qevent_h (QTextBlockGroup ()) ((QEvent t1)) where
 event_h x0 (x1)
  = withBoolResult $
    withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_event cobj_x0 cobj_x1

foreign import ccall "qtc_QTextBlockGroup_event" qtc_QTextBlockGroup_event :: Ptr (TQTextBlockGroup a) -> Ptr (TQEvent t1) -> IO CBool

instance Qevent_h (QTextBlockGroupSc a) ((QEvent t1)) where
 event_h x0 (x1)
  = withBoolResult $
    withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    qtc_QTextBlockGroup_event cobj_x0 cobj_x1

instance QsetHandler (QTextBlockGroup ()) (QTextBlockGroup x0 -> QObject t1 -> QEvent t2 -> IO (Bool)) where
 setHandler _eobj _eid _handler
  = do
    funptr  <- wrapSetHandler_QTextBlockGroup3 setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetHandler_QTextBlockGroup3_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      withCWString _eid $ \cstr_eid ->
      qtc_QTextBlockGroup_setHandler3 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)
    setHandlerWrapper x0 x1 x2
      = do x0obj <- qTextBlockGroupFromPtr x0
           x1obj <- qObjectFromPtr x1
           x2obj <- objectFromPtr_nf x2
           let rv =
                if (objectIsNull x0obj)
                 then return False
                 else _handler x0obj x1obj x2obj
           rvf <- rv
           return (toCBool rvf)

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

foreign import ccall "qtc_QTextBlockGroup_setHandler3" qtc_QTextBlockGroup_setHandler3 :: Ptr (TQTextBlockGroup a) -> CWString -> Ptr (Ptr (TQTextBlockGroup x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()

foreign import ccall "wrapper" wrapSetHandler_QTextBlockGroup3 :: (Ptr (TQTextBlockGroup x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> IO (FunPtr (Ptr (TQTextBlockGroup x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)))

foreign import ccall "wrapper" wrapSetHandler_QTextBlockGroup3_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))

instance QsetHandler (QTextBlockGroupSc a) (QTextBlockGroup x0 -> QObject t1 -> QEvent t2 -> IO (Bool)) where
 setHandler _eobj _eid _handler
  = do
    funptr  <- wrapSetHandler_QTextBlockGroup3 setHandlerWrapper
    stptr   <- newStablePtr (Wrap _handler)
    funptr_d  <- wrapSetHandler_QTextBlockGroup3_d setHandlerWrapper_d
    withObjectPtr _eobj $ \cobj_eobj ->
      withCWString _eid $ \cstr_eid ->
      qtc_QTextBlockGroup_setHandler3 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
    return()
  where
    setHandlerWrapper :: Ptr (TQTextBlockGroup x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)
    setHandlerWrapper x0 x1 x2
      = do x0obj <- qTextBlockGroupFromPtr x0
           x1obj <- qObjectFromPtr x1
           x2obj <- objectFromPtr_nf x2
           let rv =
                if (objectIsNull x0obj)
                 then return False
                 else _handler x0obj x1obj x2obj
           rvf <- rv
           return (toCBool rvf)

    setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
    setHandlerWrapper_d funptr stptr funptr_d
      = do when (stptr/=ptrNull)
            (freeStablePtr (castPtrToStablePtr stptr))
           when (funptr/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr))
           when (funptr_d/=ptrNull)
            (freeHaskellFunPtr (castPtrToFunPtr funptr_d))
           return ()

instance QeventFilter_h (QTextBlockGroup ()) ((QObject t1, QEvent t2)) where
 eventFilter_h x0 (x1, x2)
  = withBoolResult $
    withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    withObjectPtr x2 $ \cobj_x2 ->
    qtc_QTextBlockGroup_eventFilter cobj_x0 cobj_x1 cobj_x2

foreign import ccall "qtc_QTextBlockGroup_eventFilter" qtc_QTextBlockGroup_eventFilter :: Ptr (TQTextBlockGroup a) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO CBool

instance QeventFilter_h (QTextBlockGroupSc a) ((QObject t1, QEvent t2)) where
 eventFilter_h x0 (x1, x2)
  = withBoolResult $
    withObjectPtr x0 $ \cobj_x0 ->
    withObjectPtr x1 $ \cobj_x1 ->
    withObjectPtr x2 $ \cobj_x2 ->
    qtc_QTextBlockGroup_eventFilter cobj_x0 cobj_x1 cobj_x2


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

    <title>increco.py — mumodo 1.0 documentation</title>

    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />

    <link rel="top" title="mumodo 1.0 documentation" href="../index.html" />
    <link rel="next" title="corpus.py" href="Corpus.html" />
    <link rel="prev" title="xiofile.py" href="XIOFile.html" />

Navigation

          index

          modules |

          next |

          previous |

mumodo 1.0 documentation »

increco.py¶

Parse IncReco files

increco.py – analysis and plotting functions

Mumodo support for inc_reco file (incremental ASR log files)

class <tt class="descclassname">mumodo.increco.</tt><tt class="descname">IncReco</tt><big>(</big>filepath<big>)</big>[source]¶

Read and parse inc_reco files

inc_reco files are a standardised form of representing icremental
results, predominantly from Automatic Speech Recogintion

The files are simple text files that are generated by incremental
speech recognizers and have a standard format of the following
form (columns are separated by tab stops, not shown):

Time: 0.40
0.00    0.20   one
0.20    0.40   <sil>

Time: 0.50
0.00    0.20  one
0.20    0.30  <sil>
0.30    0.50  one

The class parses the files, and allows per chunk access (two
chunks are shown above. So IncReco(file)[0] will yield the
first chunk, and normal slicing will give ranges of chunks,
e.g. IncReco(file)[3:5]. The object can be iterated over and
has a length (total number of chunks)

The chunks are returned as dictionaries with keys “Time” for
the response time and Chunk, a list of the chunk rows. Each
row is itself a list with items [start, end, text], e.g. the
first chunk above is returned as:

{‘Time’: 0.40, ‘Chunk’: [[0.0, 0.2, ‘one’], [0.2, 0.4, ‘<sil>’]}

Two special methods are also impelemented for getting the
latest chunk at a specified response time, and for getting the
final chunk, which contains the final results and is often the
only wanted chunk.

<tt class="descname">__init__</tt><big>(</big>filepath<big>)</big>[source]¶

Initialize the IncReco object

Arguments:

filepath – the path to an inc_reco file

<tt class="descname">__parse__</tt><big>(</big><big>)</big>[source]¶

parse the inc_reco file

Each incremental output becomes a chunk in the
IncReco object

<tt class="descname">__weakref__</tt>¶

list of weak references to the object (if defined)

<tt class="descname">get_last_chunk</tt><big>(</big><big>)</big>[source]¶

Get the very last chunk

This is convenient when we are not interested in
the intermediate results, but only the final output

<tt class="descname">get_latest_chunk</tt><big>(</big>chunktime<big>)</big>[source]¶

Get the latest chunk at a specific time

chunktime: the time M.SS (minutes, seconds) of the chunk

This will return the latest chunk available at the given
time

<tt class="descname">get_times</tt><big>(</big><big>)</big>[source]¶

Get the chunk times

The labels are the times at which each chunk is reported

Previous topic

xiofile.py

Next topic

corpus.py

This Page

Show Source

Quick search

    <form class="search" action="../search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>

    Enter search terms or a module, class or function name.

Navigation

          index

          modules |

          next |

          previous |

mumodo 1.0 documentation »

        © Copyright 2014, Dialogue Systems Group.
      Created using Sphinx 1.2.3.


text:
<?xml version="1.0" encoding="UTF-8"?>
<Module>
<ModulePrefs title="Programmable Digital Timer"
     title_url="http://www.dapj.com/digitaltimer"
     description="Set Time, Start Timer, Audio-Visual Alarm Sounds when Set Time Reached"
     height="220" width="220"
     directory_title="Programmable Digital Timer"
     author="dapj"
     author_location="Bangalore, India"
     author_affiliation="dapj.com"
     screenshot="http://programmable-digital-timer.googlecode.com/svn/trunk/digtimer.png"
     thumbnail="http://programmable-digital-timer.googlecode.com/svn/trunk/digtimer-tn.png"
     scaling="false"
     scrolling="false"
     author_photo="http://seven-segment-digital-clock.googlecode.com/svn/trunk/delogo.png"
     author_aboutme="Electronic Product Designer"
     author_link="http://www.dapj.com/"
     author_quote="Design with a Difference - Solderman"
     author_email="gadgets@dapj.com"/>
<Content type="html"><![CDATA[
<iframe src="http://programmable-digital-timer.googlecode.com/svn/trunk/d-timer.html" allowtransparency="true" frameborder="0" height="220" scrolling="no" width="220"></iframe>
]]></Content>
</Module>


text:
================
Thrift Connector
================

The Thrift connector makes it possible to integrate with external storage systems
without a custom Presto connector implementation by using
`Apache Thrift <https://thrift.apache.org/>`_ on these servers. It is therefore generic and can provide access any backend, as long as it exposes the expected API by using Thrift.

In order to use the Thrift connector with an external system, you need to implement
the ``PrestoThriftService`` interface, found below. Next, you configure the Thrift connector
to point to a set of machines, called Thrift servers, that implement the interface.
As part of the interface implementation, the Thrift servers provide metadata,
splits and data. The connector randomly chooses a server to talk to from the available
instances for metadata calls, or for data calls unless the splits include a list of addresses.
All requests are assumed to be idempotent and can be retried freely among any server.

Configuration
-------------

To configure the Thrift connector, create a catalog properties file
``etc/catalog/thrift.properties`` with the following content,
replacing the properties as appropriate:

.. code-block:: none

    connector.name=presto-thrift
    presto.thrift.client.addresses=host:port,host:port

Multiple Thrift Systems
^^^^^^^^^^^^^^^^^^^^^^^

You can have as many catalogs as you need, so if you have additional
Thrift systems to connect to, simply add another properties file to ``etc/catalog``
with a different name, making sure it ends in ``.properties``.

Configuration Properties
------------------------

The following configuration properties are available:

=============================================  ==============================================================
Property Name                                  Description
=============================================  ==============================================================
``presto.thrift.client.addresses``             Location of Thrift servers
``presto-thrift.max-response-size``            Maximum size of data returned from Thrift server
``presto-thrift.metadata-refresh-threads``     Number of refresh threads for metadata cache
``presto.thrift.client.max-retries``           Maximum number of retries for failed Thrift requests
``presto.thrift.client.max-backoff-delay``     Maximum interval between retry attempts
``presto.thrift.client.min-backoff-delay``     Minimum interval between retry attempts
``presto.thrift.client.max-retry-time``        Maximum duration across all attempts of a Thrift request
``presto.thrift.client.backoff-scale-factor``  Scale factor for exponential back off
``presto.thrift.client.connect-timeout``       Connect timeout
``presto.thrift.client.request-timeout``       Request timeout
``presto.thrift.client.socks-proxy``           SOCKS proxy address
``presto.thrift.client.max-frame-size``        Maximum size of a raw Thrift response
``presto.thrift.client.transport``             Thrift transport type (``UNFRAMED``, ``FRAMED``, ``HEADER``)
``presto.thrift.client.protocol``              Thrift protocol type (``BINARY``, ``COMPACT``, ``FB_COMPACT``)
=============================================  ==============================================================

``presto.thrift.client.addresses``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Comma-separated list of thrift servers in the form of ``host:port``. For example:

.. code-block:: none

    presto.thrift.client.addresses=192.0.2.3:7777,192.0.2.4:7779

This property is required; there is no default.

``presto-thrift.max-response-size``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Maximum size of a data response that the connector accepts. This value is sent
by the connector to the Thrift server when requesting data, allowing it to size
the response appropriately.

This property is optional; the default is ``16MB``.

``presto-thrift.metadata-refresh-threads``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Number of refresh threads for metadata cache.

This property is optional; the default is ``1``.

Thrift IDL File
---------------

The following IDL describes the ``PrestoThriftService`` that must be implemented:

.. literalinclude:: /include/PrestoThriftService.thrift
    :language: thrift


text:
tcard:
	./bin/tcardgen -o static/tcard -t og-picture-assets/og-picture-template.png -f og-picture-assets/fonts content/veille/*.md


text:
from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [
        ('db', '0005_auto_20180714_2104'),
    ]

    operations = [
        migrations.AlterField(
            model_name='telegramuser',
            name='username',
            field=models.CharField(max_length=32, null=True),
        ),
    ]


text:
  <meta charset="utf-8">
  <link rel="stylesheet" href="notifier_popup.css"/>

Toutes les notifications

«Vous zestes les bienvenus.»

Connexion


text:
=head1 LICENSE

Copyright [1999-2015] Wellcome Trust Sanger Institute and the EMBL-European Bioinformatics Institute
Copyright [2016-2018] EMBL-European Bioinformatics Institute

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

=cut

package EnsEMBL::REST::Model::Lookup;

use Moose;
use namespace::autoclean;
use Try::Tiny;
use Catalyst::Exception;
use Scalar::Util qw/weaken/;

extends 'Catalyst::Model';
with 'Catalyst::Component::InstancePerContext';

# Config
has 'lookup_model' => ( is => 'ro', isa => 'Str', required => 1, default => 'DatabaseIDLookup' );

has 'no_long_lookup' => (is => 'ro', isa => 'Bool');

# Per instance variables
has 'context' => (is => 'ro', weak_ref => 1);

sub build_per_context_instance {
  my ($self, $c, @args) = @_;
  weaken($c);
  return $self->new({ context => $c, %$self, @args });
}

sub find_cafe_by_genetree {
  my ($self, $gt) = @_;
  my $c = $self->context();
  my $compara_name = $c->request->parameters->{compara};
  my $reg = $c->model('Registry');

  my $cafa = $gt->adaptor->db()->get_CAFEGeneFamilyAdaptor();
  Catalyst::Exception->throw("No get_CAFEGeneFamily adaptor found ") unless $cafa;
  my $cafe_object = $cafa->fetch_by_GeneTree($gt);

  return $cafe_object;

}

sub find_family_by_stable_id {
  my ($self, $id) = @_;
  my $fam;
  my $c = $self->context();
  my $compara_name = $c->request->parameters->{compara};
  my $reg = $c->model('Registry');

  #Force search to use compara as the DB type
  $c->request->parameters->{db_type} = 'compara' if ! $c->request->parameters->{db_type};
  $c->request->parameters->{object_type} = 'family' if ! $c->request->parameters->{object_type};
  #Try to do a lookup if the ID DB is there
  my $lookup = $reg->get_DBAdaptor('multi', 'stable_ids', 1);
  if($lookup) {
    my ($species, $object_type, $db_type) = $self->find_object_location($id);
    if($species) {
      my $fama = $reg->get_adaptor($species, $db_type, $object_type);
      Catalyst::Exception->throw("No adaptor found for ID $id, species $species, object $object_type and db $db_type") unless $fama;
      $fam = $fama->fetch_by_stable_id($id);
    }
  }
  #If we haven't got one then do a linear search
  if(! $fam) {
    my $comparas = $c->model('Registry')->get_all_DBAdaptors('compara', $compara_name);
    foreach my $c (@{$comparas}) {
      my $fama = $c->get_FamilyAdaptor();
      $fam = $fama->fetch_by_stable_id($id);
      last if $fam;
    }
  }
  return $fam if $fam;
  Catalyst::Exception->throw("No Family found for ID $id");

}

sub find_family_by_member_id {
  my ($self,$id) = @_;
  my $c = $self->context();
  my $compara_name = $c->request->parameters->{compara};
  my $reg = $c->model('Registry');

  my ($species, $object_type, $db_type) = $self->find_object_location($id);

  # The rest of the method should treat all the possible $object_type and
  # $db_type, and output the relevant error messages
  Catalyst::Exception->throw("Unable to find given object: $id") unless $species;
  Catalyst::Exception->throw("'$id' is not an Ensembl Core object, and thus does not have a gene-tree.") if $db_type ne 'core';

  my $dba = $reg->get_best_compara_DBAdaptor($species,$compara_name);
  my $fama = $dba->get_FamilyAdaptor;
  my $member;
  my $fam;
  if ($object_type eq 'Gene') {
    $member = $dba->get_GeneMemberAdaptor->fetch_by_stable_id($id);
    Catalyst::Exception->throw("Could not fetch a $object_type object for ID $id") unless $member;
    $fam = $fama->fetch_all_by_GeneMember($member);
  } elsif ($object_type eq 'Transcript') {
    $member = $dba->get_SeqMemberAdaptor->fetch_by_stable_id($id);
    Catalyst::Exception->throw("Could not fetch a $object_type object for ID $id") unless $member;
    $fam = $fama->fetch_by_SeqMember($member);
  } elsif ($object_type eq 'Translation') {
    my $translation_adaptor = $reg->get_adaptor($species, $db_type, 'Translation');
    my $translation = $translation_adaptor->fetch_by_stable_id($id);
    $member = $dba->get_SeqMemberAdaptor->fetch_by_stable_id($translation->stable_id);
    $fam = $fama->fetch_by_SeqMember($member);
  } elsif ($object_type eq 'Exon') {
    my $gene_adaptor = $reg->get_adaptor($species, $db_type, 'Gene');
    my $gene = $gene_adaptor->fetch_by_exon_stable_id($id);
    $member = $dba->get_GeneMemberAdaptor->fetch_by_stable_id($gene->stable_id);
    $fam = $fama->fetch_all_by_GeneMember($member);
  }
  Catalyst::Exception->throw("No Family found for $object_type ID $id") unless $fam;
  return $fam;
}

sub find_genetree_by_stable_id {
  my ($self, $id) = @_;
  my $gt;
  my $c = $self->context();
  my $compara_name = $c->request->parameters->{compara};
  my $reg = $c->model('Registry');

  #Force search to use compara as the DB type
  $c->request->parameters->{db_type} = 'compara' if ! $c->request->parameters->{db_type};

  #Try to do a lookup if the ID DB is there
  my $lookup = $reg->get_DBAdaptor('multi', 'stable_ids', 1);

  if($lookup) {
    my ($species, $object_type, $db_type) = $self->find_object_location($id);
    if($species) {
      my $gta = $reg->get_adaptor($species, $db_type, $object_type);
      Catalyst::Exception->throw("No adaptor found for ID $id, species $species, object $object_type and db $db_type") unless $gta;
      $gt = $gta->fetch_by_stable_id($id);
    }
  }
  #If we haven't got one then do a linear search
  if(! $gt) {
    my $comparas = $c->model('Registry')->get_all_DBAdaptors('compara', $compara_name);

    foreach my $c (@{$comparas}) {
      my $gta = $c->get_GeneTreeAdaptor();
      $gt = $gta->fetch_by_stable_id($id);
      last if $gt;
    }
  }
  return $gt if $gt;
  Catalyst::Exception->throw("No GeneTree found for ID $id");
}

sub find_genetree_by_member_id {
  my ($self,$id) = @_;
  my $c = $self->context();
  my $compara_name = $c->request->parameters->{compara};
  my $reg = $c->model('Registry');

  my ($species, $object_type, $db_type) = $self->find_object_location($id);
  # The rest of the method should treat all the possible $object_type and
  # $db_type, and output the relevant error messages
  Catalyst::Exception->throw("Unable to find given object: $id") unless $species;
  Catalyst::Exception->throw("'$id' is not an Ensembl Core object, and thus does not have a gene-tree.") if $db_type ne 'core';

  my $dba = $reg->get_best_compara_DBAdaptor($species,$compara_name);

  my $member;
  if ($object_type eq 'Gene') {
    $member = $dba->get_GeneMemberAdaptor->fetch_by_stable_id($id);
  } elsif ($object_type eq 'Transcript') {
    my $gene_adaptor = $reg->get_adaptor($species, $db_type, 'Gene');
    my $gene = $gene_adaptor->fetch_by_transcript_stable_id($id);
    $member = $dba->get_GeneMemberAdaptor->fetch_by_stable_id($gene->stable_id);
  } elsif ($object_type eq 'Translation') {
    my $translation_adaptor = $reg->get_adaptor($species, $db_type, 'Translation');
    my $translation = $translation_adaptor->fetch_by_stable_id($id);
    $member = $dba->get_SeqMemberAdaptor->fetch_by_stable_id($translation->stable_id);
  } elsif ($object_type eq 'Exon') {
    my $gene_adaptor = $reg->get_adaptor($species, $db_type, 'Gene');
    my $gene = $gene_adaptor->fetch_by_exon_stable_id($id);
    $member = $dba->get_GeneMemberAdaptor->fetch_by_stable_id($gene->stable_id);
  }
  Catalyst::Exception->throw("Could not fetch a $object_type object for ID $id") unless $member;

  my $clusterset_id = $c->request->parameters->{clusterset_id};
  my $gta = $dba->get_GeneTreeAdaptor;
  my $gt = $gta->fetch_default_for_Member($member, $clusterset_id);
  Catalyst::Exception->throw("No GeneTree found for $object_type ID $id") unless $gt;
  return $gt;
}

#Find all the Method objects in the compara database
sub find_compara_methods {
  my ($self, $class) = @_;
  my $c = $self->context();
  #default is "multi"
  my $compara = $c->request->parameters->{compara} || $c->config->{'Controller::Compara'}->{default_compara} || 'multi';
  my $reg = $c->model('Registry');
  my $compara_dba = $reg->get_DBAdaptor($compara, "compara");
  my $methods;
  if($class) {
    $methods = $compara_dba->get_MethodAdaptor->fetch_all_by_class_pattern($class);
  }
  else {
    $methods = $compara_dba->get_MethodAdaptor->fetch_all();
  }
  return $methods;
}

#Find all the species_sets for this method in the compara database
sub find_compara_species_sets {
  my ($self, $method) = @_;

  my $c = $self->context();
  #default is "multi"
  my $compara = $c->request->parameters->{compara} || $c->config->{'Controller::Compara'}->{default_compara} || 'multi';
  my $reg = $c->model('Registry');
  my $compara_dba = $reg->get_DBAdaptor($compara, "compara");

  my @results;

  #Get MethodLinkSpeciesSet objects
  my $mlsss = $compara_dba->get_MethodLinkSpeciesSetAdaptor->fetch_all_by_method_link_type($method);
  foreach my $mlss (@$mlsss) {
    my $species_set = {};
    my $species_set_obj = $mlss->species_set();
    my @species_set_genomes = map { $_->name } @{$species_set_obj->genome_dbs};
    $species_set->{species_set_group} = $species_set_obj->name;
    $species_set->{name} = $mlss->name;
    $species_set->{species_set} = \@species_set_genomes;
    $species_set->{method} = $mlss->method()->type();
    push(@results, $species_set);
  }
  return \@results;
}

# uses the request for more optional arguments
sub find_object_by_stable_id {
  my ($self, $id) = @_;
  my $c = $self->context();
  my ($species, $object_type, $db_type) = $self->find_object_location($id);
  return $self->find_object($id, $species, $object_type, $db_type);
}

sub find_object {
  my ($self, $id, $species, $object_type, $db_type) = @_;
  my $c = $self->context();
  my $r = $c->request();
  my $reg = $c->model('Registry');
  $object_type = $r->param('object_type') if !$object_type;
  Catalyst::Exception->throw("ID '$id' not found") unless $species;
  my $adaptor = $reg->get_adaptor($species, $db_type, $object_type);
  $c->log()->debug('Found an adaptor '.$adaptor);
  if(! $adaptor->can('fetch_by_stable_id')) {
    Catalyst::Exception->throw("Object, $object_type, type's adaptor does not support fetching by a stable ID for ID '$id'");
  }
  my $final_obj = $adaptor->fetch_by_stable_id($id);
  Catalyst::Exception->throw("No object found for ID $id") unless $final_obj;
  $c->stash()->{object} = $final_obj;
  return $final_obj;
}

sub find_objects_by_symbol {
  my ($self, $symbol) = @_;
  my $c = $self->context();
  my $db_type = $c->request->param('db_type') || 'core';
  my $external_db = $c->request->param('external_db');
  my @entries;
  my @objects_to_try = $c->request->param('object_type') ? ($c->request->param('object_type')) : qw(gene transcript translation);
  foreach my $object_type (@objects_to_try) {
    my $object_adaptor = $c->model('Registry')->get_adaptor($c->stash->{'species'}, $db_type, $object_type);
    my $objects_linked_to_symbol = $object_adaptor->fetch_all_by_external_name($symbol, $external_db);
    while(my $obj = shift @{$objects_linked_to_symbol}) {
      $c->log()->debug("Found by symbol ".$symbol." ".$obj);
      push(@entries, $obj);
    }
  }

  # If we ran out of possible symbols then switch onto using the gene's display label
  if(! @entries) {
    my $object_param = $c->request->param('object_type');
    if(! defined $object_param || (defined $object_param && $object_param eq 'gene') ) {
      my $object_adaptor = $c->model('Registry')->get_adaptor($c->stash->{'species'}, $db_type, 'gene');
      my $objects_linked_to_symbol = $object_adaptor->fetch_all_by_display_label($symbol);
      while(my $obj = shift @{$objects_linked_to_symbol}) {
        $c->log()->debug("Found by symbol ".$symbol." ".$obj);
        push(@entries, $obj);
      }
    }
  }

  return \@entries;
}

sub find_object_location {
  my ($self, $id) = @_;
  my $no_long_lookup = $self->no_long_lookup();
  my $c = $self->context();
  my $r = $c->request;
  my $log = $c->log();

  my ($object_type, $db_type, $species, $use_archive) = map { my $p = $r->param($_); $p; } qw/object_type db_type species use_archive/;
  my @captures;

  #If all 3 params were specified then let it through. User knows best
  if($object_type && $db_type && $species) {
    @captures = ($species, $object_type, $db_type);
  }
  elsif($object_type && $object_type eq 'predictiontranscript') {
    @captures = $c->model('LongDatabaseIDLookup')->find_object_location($id, $object_type, $db_type, $species);
  }
  else {
    $c->log()->debug(sprintf('Looking for %s with %s and %s in %s', $id, ($object_type || q{?}), ($db_type || q{?}), ($species || q{?})));
    my $model_name = $self->lookup_model();
    my $lookup = $c->model($model_name);
    @captures = $lookup->find_object_location($id, $object_type, $db_type, $species, $use_archive);
    #Check if we any conntent or if the 1st element was false (both mean force a long lookup)
    unless ((@captures && $captures[0]) || $no_long_lookup) {
      $c->log()->debug('Using long database lookup');
      @captures = $c->model('LongDatabaseIDLookup')->find_object_location($id, $object_type, $db_type, $species);
    }
  }

  if($log->is_debug()) {
    if(@captures && $captures[0]) {
      $log->debug(sprintf('Found %s, %s and %s', @captures));
    }
    else {
      $log->debug('Found no ID');
      if ($use_archive) {
        my $reg = $c->model('Registry');
        my $lookup = $reg->get_DBAdaptor('multi', 'stable_ids', 1);
        Catalyst::Exception->throw("No lookup database available on server, archive lookup not possible for $id. Please contact the administrator of this server") unless $lookup;
      }
      Catalyst::Exception->throw("No object found for $id");
    }
  }

  $c->stash(species => $captures[0], object_type => $captures[1], group => $captures[2]);

  return @captures;
}

sub fetch_archive_by_id {
  my ($self, $stable_id) = @_;

  my $c = $self->context();
  my $archive;

  my @results = $self->find_object_location($stable_id, undef, 1);
  if (!defined $results[0]) {
    Catalyst::Exception->throw("No object found for $stable_id");
  }
  my $species = $results[0];
  # We need to accept the type from find_object_location because some
  # species like C. elegans don't have a pattern the type lookup can
  # identify, and things go very badly
  my $type = $results[1] ? $results[1] : undef;
  my $adaptor = $c->model('Registry')->get_adaptor($species,'Core','ArchiveStableID');

  # Lookup the stable_id, passing along the identifier type if we have it
  $archive = $adaptor->fetch_by_stable_id($stable_id, $type);
  $c->stash()->{archive} = $archive;
}

sub find_and_locate_object {
  my ($self, $id) = @_;
  my $c = $self->context();

  my @captures = $self->find_object_location($id);
  my $species = $captures[0];
  my $object_type = $captures[1];
  my $db_type = $captures[2];
  my $features = $self->features_as_hash($id, $species, $object_type, $db_type);
  my $input_type = lc($features->{object_type});

  #include phenotypes for genes
  my $phenotypes = $c->request->param('phenotypes');
  if($phenotypes && $input_type eq 'gene'){
    #fetch the gene phenotype info
    $features->{'phenotypes'} = $self->phenotypes($features->{id});
  }

  my $expand = $c->request->param('expand');
  if ($expand) {
    if ($input_type eq 'gene') {
      $features->{'Transcript'} = $self->Transcript($features->{id}, $species, $db_type);
    } elsif ($input_type eq 'transcript') {
      $features = $self->transcript_feature($features->{id}, $species, $db_type);
    } else {
      Catalyst::Exception->throw("Expand option only available for Genes and Transcripts");
    }
  }

  return $features;
}

sub find_and_locate_list {
  my ($self, $id_list) = @_;
  my $c = $self->context();
  my %combined_list;
  while (my $id = shift @$id_list) {
    my $objs;
    try {
      $objs = find_and_locate_object($self,$id);
    }
    catch {
      $c->log->debug("No object found for ID $id");
      # No objects found, report an empty variable
    };
    $combined_list{$id} = $objs;
  }
  return \%combined_list;
}

sub find_gene_by_symbol {
  my ($self, $symbol) = @_;
  my $c = $self->context();
  my $species = $c->stash->{'species'};

  my $gene_adaptor = $c->model('Registry')->get_adaptor($species, 'core', 'Gene');
  my $gene = $gene_adaptor->fetch_by_display_label($symbol);
  Catalyst::Exception->throw(qq{No valid lookup found for symbol $symbol}) unless $gene;
  my $features = $self->features_as_hash($gene->stable_id, $species, 'Gene', 'core', $gene);

  my $expand = $c->request->param('expand');
  if ($expand) {
    $features->{'Transcript'} = $self->Transcript($features->{id}, $species, 'core');
  }

  return $features;
}

sub find_genes_by_symbol_list {
  my ($self, $list) = @_;
  my %genes;
  while (my $symbol = shift @$list) {
    try {
      my $gene = find_gene_by_symbol($self,$symbol);
      $genes{$symbol} = $gene if $gene;
    }
    catch {

    };
  }
  return \%genes;
}

sub Transcript {
  my ($self, $id, $species, $db_type) = @_;

  my @transcripts;
  my $features;
  my $object = $self->find_object($id, $species, 'Gene', $db_type);
  my $transcripts = $object->get_all_Transcripts;
  foreach my $transcript (@$transcripts) {
    push @transcripts, $self->transcript_feature($transcript->stable_id, $species, $db_type);
  }
  return \@transcripts;
}

sub transcript_feature {
  my ($self, $id, $species, $db_type) = @_;
  my $features;
  my $transcript = $self->find_object($id, $species, 'Transcript', $db_type);
  $features = $self->features_as_hash($id, $species, 'Transcript', $db_type, $transcript);
  $features->{Exon} = $self->Exon($transcript, $species, $db_type);
  if ($transcript->translate) {
    my $translation = $transcript->translation;
    $features->{Translation} = $self->features_as_hash($translation->stable_id, $species, 'Translation', $db_type, $translation);
  }
  if ($self->context->request->param('utr')) {
    $features->{UTR} = $self->UTR($transcript, $species, $db_type) ;
  }
  return $features;
}

sub UTR {
  my ($self, $transcript, $species, $db_type) = @_;

  my @utrs;
  my $features;
  my $five_utr = $transcript->get_all_five_prime_UTRs();
  foreach my $five (@$five_utr) {
    push @utrs, $self->features_as_hash($transcript->stable_id, $species, 'five_prime_UTR', $db_type, $five);
  }
  my $three_utr = $transcript->get_all_three_prime_UTRs();
  foreach my $three (@$three_utr) {
    push @utrs, $self->features_as_hash($transcript->stable_id, $species, 'three_prime_UTR', $db_type, $three);
  }

  return \@utrs;
}

sub Exon {
  my ($self, $transcript, $species, $db_type) = @_;

  my @exons;
  my $exons = $transcript->get_all_Exons;
  foreach my $exon(@$exons) {
    push @exons, $self->features_as_hash($exon->stable_id, $species, 'Exon', $db_type, $exon);
  }

  return \@exons;
}

sub features_as_hash {
  my ($self, $id, $species, $object_type, $db_type, $obj) = @_;

  my $c = $self->context();
  my $format = $c->request->param('format') || 'full';
  my $features;
  $features->{id} = $id;
  $features->{species} = $species;
  $features->{object_type} = $object_type;
  $features->{db_type} = $db_type;

  if ($format eq 'full') {
    $obj = $self->find_object($id, $species, $object_type, $db_type) if !$obj;
    if($obj->can('summary_as_hash')) {
      my $summary_hash = $obj->summary_as_hash();
# Not all features have all labels
# Seq_region_name, start and end are available for genes, transcripts and exons but not translations
      $features->{seq_region_name} = $summary_hash->{seq_region_name} if defined $summary_hash->{seq_region_name};
      if (!$obj->isa('Bio::EnsEMBL::Translation')) {
        $features->{assembly_name} = $obj->slice->coord_system->version() if $obj->slice();
      }
      $features->{start} = $summary_hash->{start} * 1 if defined $summary_hash->{start};
      $features->{end} = $summary_hash->{end} * 1 if defined $summary_hash->{end};
      $features->{strand} = $summary_hash->{strand} * 1 if defined $summary_hash->{strand};
# Translations start and end are genomic coordinates
      $features->{start} = $summary_hash->{genomic_start} if defined $summary_hash->{genomic_start};
      $features->{end} = $summary_hash->{genomic_end} if defined $summary_hash->{genomic_end};
# Translation length provided separately
      $features->{length} = $summary_hash->{length} if defined $summary_hash->{length};
# Display_name and description are available for genes and sometimes for transcripts
      $features->{display_name} = $summary_hash->{Name} if defined $summary_hash->{Name};
      $features->{description} = $summary_hash->{description} if defined $summary_hash->{description};
      $features->{version} = $summary_hash->{version} * 1 if defined $summary_hash->{version};
# Biotype, source and logic_name are only available for genes and transcripts
      $features->{biotype} = $summary_hash->{biotype} if defined $summary_hash->{biotype};
      $features->{source} = $summary_hash->{source} if defined $summary_hash->{source};
      $features->{logic_name} = $summary_hash->{logic_name} if defined $summary_hash->{logic_name};
# Parent field to link back to gene/transcript where available
      $features->{Parent} = $summary_hash->{Parent} if defined $summary_hash->{Parent};
      if (lc($object_type) eq 'transcript') {
        $features->{is_canonical} = $obj->is_canonical;
      }
    } else {
      Catalyst::Exception->throw(qq{ID '$id' does not support 'full' format type. Please use 'condensed'});
    }
  }

  return $features;
}

sub find_slice {
  my ($self, $region) = @_;
  my $c = $self->context();
  my $s = $c->stash();
  # don't do this.
  my $species = $s->{species};
  # or this
  my $db_type = $s->{db_type} || 'core';
  my $adaptor = $c->model('Registry')->get_adaptor($species, $db_type, 'slice');
  Catalyst::Exception->throw("Do not know anything about the species $species and core database") unless $adaptor;
  my $coord_system_version = $c->request->param('coord_system_version');
  my $coord_system_name = $c->request->param('coord_system') || 'toplevel';
  if ($coord_system_version && !$c->request->param('coord_system')) { $coord_system_name = 'chromosome'; }
  Catalyst::Exception->throw("Coord_system $coord_system_name is not valid") if $coord_system_name !~ /^[A-Za-z]+$/;
  my ($no_warnings, $no_fuzz, $ucsc_matching) = (undef, undef, 1);
  my $slice = $adaptor->fetch_by_location($region, $coord_system_name, $coord_system_version, $no_warnings, $no_fuzz, $ucsc_matching);
  Catalyst::Exception->throw("No slice found for location $region") unless $slice;
  $s->{slice} = $slice;
  return $slice;
}

sub decode_region {
  my ($self, $region, $no_warnings, $no_errors) = @_;
  my $c = $self->context();
  my $s = $c->stash();
  ## Add sanity check before API call to avoid stack trace
  my ($region_check, $start_check, $second_delimiter, $end_check, $strand_check) = $region =~ /^([0-9A-Za-z\_\.]+):?(-?[\w]*)(\.|_|-|:*)(-?[0-9A-Z]*):?(-?[0-9]?)/;
  $start_check = 1 if !$start_check;
  $end_check = $start_check+1 if !$end_check;
  $strand_check = 1 if !$strand_check;
  Catalyst::Exception->throw("Location $region not understood") unless $region_check;
  Catalyst::Exception->throw("$start_check is not a valid start") if ($start_check < 0 || $start_check !~ /[0-9]+/);
  Catalyst::Exception->throw("$end_check is not a valid end") if $end_check !~ /[0-9]+/;
  Catalyst::Exception->throw("$strand_check is not a valid strand") if $strand_check !~ /^-?1$/;
  my $species = $s->{species};
  my $adaptor = $c->model('Registry')->get_adaptor($species, 'core', 'slice');
  Catalyst::Exception->throw("Do not know anything about the species $species and core database")unless $adaptor;
  my ($sr_name, $start, $end, $strand) = $adaptor->parse_location_to_values($region, $no_warnings, $no_errors);
  $strand = 1 if ! defined $strand;
  Catalyst::Exception->throw("Could not decode region $region") unless $sr_name;
  $s->{sr_name} = $sr_name;
  $s->{start} = $start;
  $s->{end} = $end;
  $s->{strand}= $strand;
  return ($sr_name, $start, $end, $strand);
}

sub ontology_accession_to_OntologyTerm {
  my ($self, $accession) = @_;
  my $c = $self->context();
  my $term_adaptor = $c->model('Registry')->get_ontology_term_adaptor();
  return $term_adaptor->fetch_by_accession($accession, 1);
}

sub phenotypes {
  my ($self, $id) = @_;
  my $c = $self->context();
  my $phenotypes = $c->model('Variation')->get_gene_phenotype_info($id);
  return $phenotypes;
}

__PACKAGE__->meta->make_immutable;

1;


text:
'use strict';

// Configuring the discussions module
angular.module('discussions').run(['Menus', function (Menus) {
	// Add the dropdown discussions
	Menus.addSubMenuItem('topbar', 'dashboard', {
		title: 'Discussions',
		state: 'discussions.list',
		roles: ['admin', 'teacher', 'supervisor', 'student']
	});
}]);


text:
package com.teamwizardry.refraction.common.network;

import com.teamwizardry.librarianlib.features.math.interpolate.numeric.InterpFloatInOut;
import com.teamwizardry.librarianlib.features.math.interpolate.position.InterpCircle;
import com.teamwizardry.librarianlib.features.network.PacketBase;
import com.teamwizardry.librarianlib.features.particle.ParticleBuilder;
import com.teamwizardry.librarianlib.features.particle.ParticleSpawner;
import com.teamwizardry.librarianlib.features.saving.Save;
import com.teamwizardry.refraction.Refraction;
import com.teamwizardry.refraction.api.Constants;
import net.minecraft.client.Minecraft;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;

import java.awt.*;
import java.util.concurrent.ThreadLocalRandom;

public class PacketWormholeParticles extends PacketBase {

	@Save
	public BlockPos pos;
	@Save
	public EnumFacing facing;

	public PacketWormholeParticles() {
	}

	public PacketWormholeParticles(BlockPos pos, EnumFacing facing) {
		this.facing = facing;
		this.pos = pos;
	}

	@Override
	public void handle(MessageContext ctx) {
		if (ctx.side.isServer()) return;

		World world = Refraction.proxy.getWorld();

		double add = 2;
		Vec3d offset;
		switch (facing) {
			case UP:
				offset = new Vec3d(0, add, 0);
				break;
			case DOWN:
				offset = new Vec3d(0, -add, 0);
				break;
			case EAST:
				offset = new Vec3d(add, 0, 0);
				break;
			case WEST:
				offset = new Vec3d(-add, 0, 0);
				break;
			case SOUTH:
				offset = new Vec3d(0, 0, add);
				break;
			case NORTH:
				offset = new Vec3d(0, 0, -add);
				break;
			default:
				offset = new Vec3d(0, add, 0);
				break;
		}

		Vec3d tmp = Minecraft.getMinecraft().player.getLook(0);
		Vec3d normal = new Vec3d(tmp.x, 0, tmp.z);

		ParticleBuilder wormholeVoid = new ParticleBuilder(10);
		wormholeVoid.setAlphaFunction(new InterpFloatInOut(0.9f, 0.9f));
		wormholeVoid.setRenderNormalLayer(new ResourceLocation(Constants.MOD_ID, "particles/glow"));
		ParticleSpawner.spawn(wormholeVoid, world, new InterpCircle(new Vec3d(pos).add(0.5, 0.5, 0.5).add(offset), normal, 1.20f, 1f, ThreadLocalRandom.current().nextFloat()), ThreadLocalRandom.current().nextInt(10, 20), 0, (aFloat, particleBuilder) -> {
			int rnd = ThreadLocalRandom.current().nextInt(0, 40);
			wormholeVoid.setColor(new Color(rnd, 0, rnd));
			wormholeVoid.setMotion(new Vec3d(
					ThreadLocalRandom.current().nextDouble(-0.01, 0.01),
					ThreadLocalRandom.current().nextDouble(-0.01, 0.01),
					ThreadLocalRandom.current().nextDouble(-0.01, 0.01)
			));
			wormholeVoid.setScale((float) ThreadLocalRandom.current().nextDouble(1, 2));
			wormholeVoid.setLifetime(ThreadLocalRandom.current().nextInt(30, 40));
		});

		ParticleBuilder wormholeHalo = new ParticleBuilder(5);
		ParticleSpawner.spawn(wormholeHalo, world, new InterpCircle(new Vec3d(pos).add(0.5, 0.5, 0.5).add(offset), normal, 1.25f, 1, ThreadLocalRandom.current().nextFloat()), ThreadLocalRandom.current().nextInt(10, 20), 0, (aFloat, particleBuilder) -> {
			wormholeHalo.setAlphaFunction(new InterpFloatInOut(0.9f, 0.9f));
			wormholeHalo.setRender(new ResourceLocation(Constants.MOD_ID, "particles/glow"));
			wormholeHalo.setScale((float) ThreadLocalRandom.current().nextDouble(1.5, 1.75));
			wormholeHalo.setLifetime(ThreadLocalRandom.current().nextInt(10, 20));
		});
	}
}


text:
package storm.trident.util;

import java.io.Serializable;
import org.jgrapht.EdgeFactory;

public class ErrorEdgeFactory implements EdgeFactory, Serializable {
    @Override
    public Object createEdge(Object v, Object v1) {
        throw new RuntimeException("Edges should be made explicitly");
    }
}