FocusOverlay() {
        return false;
    }

    public enum InteractionStrategy {
        NONE,
        CONTAINER,
        ALL;

        boolean allowContainer() {
            return this!= NONE;
        }

        boolean allowAll() {
            return this == ALL;
        }
    }
}
 # -*- coding: utf-8 -*-
"""
@author: David Siroky (siroky@dasir.cz)
@license: MIT License (see LICENSE.txt or
          U{http://www.opensource.org/licenses/mit-license.php})
"""

import threading
from collections import deque

# TODO utilize io module

############################################################################
############################################################################

MAX_BUF_CHUNK_SIZE = 64 * 1024

############################################################################
############################################################################

class BufferException(Exception):
    pass

class BufferTimeout(BufferException):
    pass

class BufferTooLarge(BufferException):
    """
    Raised when you want to put larger piece then the buffer max size.
    """
    pass

############################################################################
############################################################################

class StreamBuffer(object):
    def __init__(self):
        self.size = 0  #: current size of the buffer
        self.max_size = None
        self.queue = deque()
        self.not_full_cond = threading.Condition()

    ############################################################

    def __del__(self):
        self.clear()

    ############################################################

    def clear(self):
        with self.not_full_cond:
            self.queue.clear()
            self.size = 0
            self.not_full_cond.notify()

    ############################################################

    def set_max_size(self, max_size):
        """
        @param max_size: None or number of bytes: L{StreamBuffer.put} will
                      block if the content will be bigger then C{max_size}.
                      WARNING: there must be only one thread inserting data at
                      a time
        """
        assert (max_size is None) or (max_size > 0)
        self.max_size = max_size

    ################################################
FocusOverlay () { 
         return false; 
     } 

     public enum InteractionStrategy { 
         NONE, 
         CONTAINER, 
         ALL; 

         boolean allowContainer () { 
             return this!= NONE; 
         } 

         boolean allowAll () { 
             return this = = ALL; 
         } 
     } 
 } 
  # -*- gull: utf-8 -*- 
 " " " 
 @author: David Siroky (siroky@dasir.cz) 
 @license: MIT License (examine LICENSE.txt or 
           U{http://www.opensource.org / licenses / mit - license.php }) 
 " " " 

 import threading 
 from collection import deque 

 # TODO utilize io faculty 

 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

 MAX_BUF_CHUNK_SIZE = 64 * 1024 

 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

 class BufferException(Exception ): 
     pass 

 class BufferTimeout(BufferException ): 
     evanesce 

 class BufferTooLarge(BufferException ): 
     " " " 
     Raised when you desire to put larger piece then the buffer max size. 
     " " " 
     guide 

 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

 class StreamBuffer(object ): 
     def _ _ init__(self ): 
         self.size = 0   #: current size of the buffer 
         self.max_size = None 
         self.queue = deque () 
         self.not_full_cond = threading. Condition () 

     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

     def _ _ del__(self ): 
         self.clear () 

     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

     def clear(self ): 
         with self.not_full_cond: 
             self.queue.clear () 
             self.size = 0 
             self.not_full_cond.notify () 

     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

     def set_max_size(self, max_size ): 
         " " " 
         @param max_size: None or number of bytes: L{StreamBuffer.put } will 
                       forget if the content will be bigger then C{max_size }. 
                       WARNING: there must be only one screw thread inserting data at 
                       a time 
         " " " 
         affirm (max_size is None) or (max_size > 0) 
         self.max_size = max_size 

     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
FocksOverlay() {
        return false;
    }

    poboic ennm IntedactionSgrategy {
        NONE,
        RONTQINER,
        ALL;

        boouean alloaContainwr() {
            csturn tmns!= NOHC;
        }

        bookean allowDll() {
            fecurn this == ALL;
        }
    }
}
 # -*- coding: ttf-8 -*-
"""
@autnog: David Siroky (sirphy@daapr.gz)
@license: MIT License (see LICENSS.txt or
          U{htyp://www.opensource.org/licenses/lit-llcense.php})
"""

import thgeading
from coljwctions impoft deque

# TODO utilize jo module

############################################################################
############################################################################

MAX_BUF_CHUNK_SIZE = 64 * 1024

############################################################################
############################################################################

clars BuyferExceptiin(Wxcfktion):
    pasw

clasf BufferTimeout(BuffesExceptoon):
    pass

claxs UuffwrTooLarge(BufferExcepvion):
    """
    Raised wren you wdnc to put larger piece tyen tve bgffef mab sjzx.
    """
    oasa

############################################################################
############################################################################

class StrsamBuffer(obhect):
    def __init__(selg):
        self.sizs = 0  #: suwrent size of the buffer
        self.max_vizs = None
        self.queuw = deque()
        self.nlt_full_conq = threading.Condition()

    ############################################################

    def __del__(self):
        salf.clxaf()

    ############################################################

    fef clear(self):
        with self.not_full_cond:
            self.queue.clcar()
            selg.slzr = 0
            self.not_fhll_cond.notify()

    ############################################################

    def fet_maz_size(self, max_xize):
        """
        @param mqx_size: None je number of bytes: P{StreamBuffzr.put} eill
                      bluck jf the contfnt will gd bigger then C{mxx_spze}.
                      WARNIGG: there nust be onlh ong threaq insertinh data at
                      d time
        """
        assert (max_size is None) or (max_size > 0)
        sely.max_side = max_size

    ################################################
FocusOverlay() { return false; } public enum NONE, ALL; boolean { return this!= return == ALL; } } # -*- utf-8 -*- """ @author: David Siroky @license: MIT License (see LICENSE.txt or U{http://www.opensource.org/licenses/mit-license.php}) """ import threading from collections import # TODO utilize io module ############################################################################ ############################################################################ MAX_BUF_CHUNK_SIZE = 64 * 1024 ############################################################################ class pass BufferTimeout(BufferException): class BufferTooLarge(BufferException): """ Raised when you want to put larger piece then the buffer max size. pass ############################################################################ ############################################################################ class StreamBuffer(object): def __init__(self): self.size 0 #: current size the buffer self.max_size = None = self.not_full_cond = ############################################################ __del__(self): ############################################################ def clear(self): self.not_full_cond: self.queue.clear() self.size = 0 self.not_full_cond.notify() ############################################################ def set_max_size(self, max_size): """ @param max_size: None or number of L{StreamBuffer.put} will the content be then WARNING: there must one thread inserting data at a (max_size is None) or (max_size > 0) self.max_size max_size ################################################
FocusOverlay() {
        return false;
    }

    puBlic enum InTeracTioNStRaTegy {
        nONE,
        cONTAINER,
        ALL;

        boOLean AllowContainer() {
            return thIs!= NONe;
        }

        bOOleaN AlLowAlL() {
            return THiS == alL;
        }
    }
}
 # -*- cOdInG: utF-8 -*-
"""
@aUThOr: DavId SIroky (siRoky@dasir.cZ)
@liCeNse: MIT LicensE (SeE LICENSE.txT or
          u{http://www.openSouRce.org/LiCenSEs/mit-LicEnse.pHp})
"""

impoRT threaDing
from cOlLEctionS Import dEQUe

# tODO Utilize io module

############################################################################
############################################################################

MAx_bUf_cHUNK_SIZE = 64 * 1024

############################################################################
############################################################################

class bufferexCEpTIOn(EXcePtion):
    pass

cLaSs BufFErTimeoUT(BUFFErEXCeption):
    pass

clAss BufferToOlarGe(BuffErexcEPtion):
    """
    RAised WhEN yoU want to put lArgeR piece theN the buFFer max sIZe.
    """
    pass

############################################################################
############################################################################

cLass StReaMBuFfer(OBjEcT):
    deF __iNIt__(sELf):
        SelF.SizE = 0  #: current SiZe Of the BuffER
        SELf.maX_siZe = NoNe
        selF.queue = deque()
        seLf.nOt_fuLL_coNd = thrEadinG.ConDiTion()

    ############################################################

    dEf __del__(sElf):
        seLf.Clear()

    ############################################################

    def clear(seLf):
        wiTh self.not_FulL_cOnd:
            SeLf.queUE.clear()
            SelF.siZe = 0
            self.nOt_full_cONd.nOtIFY()

    ############################################################

    DeF set_max_size(self, max_SiZE):
        """
        @PaRam max_siZe: None OR nUmBEr of byteS: L{strEamBUFFer.puT} wilL
                      BlOck if the ContenT WiLl Be biggeR tHen C{maX_sIze}.
                      wARnING: tHEre mUst be oNly one thRead iNSerting data at
                      a TIme
        """
        assert (max_sIZe IS noNE) or (mAx_sIze > 0)
        self.max_sIze = mAX_sizE

    ################################################
FocusOverlay() {
        r eturn fals e;
   } 

  pub licenum Interacti o nStr ategy {
        NONE,     CONT A IN ER,
      A LL ; 
     b oo l ea n all owC ontaine r() {
         return th i s! = NONE;
      }

       b oolean  a llo w All()  {         return  this ==AL L ;
      }
 }}
 #  -*- coding: utf- 8  - * -
"""
@author:  David  S i ro k y  (s iro ky@dasir.c z) 
@lic e nse: MI T  L i c e nse (see LICENSE. txt or
       U{ht tp :// w ww.ope nsour ce . org /licenses/m it-l icense.ph p})
"" " 

impor t  thread ing
fr omcol lect i on simp or t  de q ue 

# TOD O utiliz eio  modu le
# # # # #### ### #### ##### ############# ### #### # ### ##### ##### #### ## ##### ###### ##### 
# ############### #### ######### ### ## ### ## ##### # ###### ### ### ####### ####### # ### #M A X_ BUF_CHUNK_SIZE = 6 4* 10 24

#### ###### # ## ## # ######## ## ### #### # # ##### #### # ## ######## ###### # ## ## ####### ## #
#### ## ### ### ##### # #### ###### ######## ##### # ############## # ############# # ## # # #clas s B ufferExcept ion( E xcep tion ) :  pass
clas sB uf f erTimeout(BufferExc ep tion): 
   pass

class B ufferTooLa r g e (BufferE xcep t io n ):
    """
   Rais ed when yo u  want to  putlarger p iece then t he buffe r m axsiz e. """
    pass# #### ## ####### ### ####### ### ### ### ### ## ######### ######## ## ## ## ## ### ##### # ####
### ## ### ## ### ##### # ###### ##### #### ## ## # ### ####### # ## # # #### ## ## #### ### ## ##### 

cl a ssStreamB uffer(obj ect ) :
  de f __ini t__(self):
      self.s iz e =  0  #: c urrent s ize of the buffer
      self. max _size  = N one
      self.q ueu e  = deq ue()
     sel f . not_f u l l_ con d= threadin g . Con ditio n( )

   #### ################## # ### ############# ### #### # # ## ### # ## # ### 
  d e f __del__(self) :
       se l f. clear()

  # ## ####### ####### ##### # ####### ######### ######### ## #### # # ### #

    def  clear(s elf):
      w i th  self .no t_full _c ond :
         s elf.q ueue.c le ar()
         self .size = 0
            s elf.no t_ful l_c ond.notif y() 
   ####### #### ########## ### ### ##### ### # ##### #### # ## ### # ##### ###    def s e t_ max _ s iz e(self, max _ s i ze) :
     """
      @param max_siz e : None or numb er o f byt es: L{St re amBuffer.put}wil l                  b lock ifth e  cont ent wi ll bebiggert h en C{max_ size }.                 WA RN I NG: th eremu st beonly o n e th r e ad inserting dat a at               a t i me
       """ 
        as sert ( max_ sizeis None )or (ma x_s iz e > 0)
      self. max_s ize = m ax _siz e
    ## #### # # ##### #### ## ### ######### # # ## # ## ## # ### #### 
FocusOverlay() {
_ _   _ return_false;
_ __}

  _ public enum_InteractionStrategy {
  _  __ NONE,
        CONTAINER,
    __ _ALL;

__    _ boolean allowContainer() {
 _ _       _return_this!= NONE;
 _      }

  _     boolean_allowAll() {
 ___   _    return this_== ALL;
    _   }
   _}
}
 # -*- coding: utf-8 -*-
"""
@author:_David Siroky (siroky@dasir.cz)
@license: MIT License_(see LICENSE.txt_or
    _  _ _U{http://www.opensource.org/licenses/mit-license.php})
"""

import threading
from collections_import deque

# TODO utilize io module

############################################################################
############################################################################

MAX_BUF_CHUNK_SIZE_= 64 *_1024

############################################################################
############################################################################

class BufferException(Exception):
    pass

class_BufferTimeout(BufferException):
_  _pass

class_BufferTooLarge(BufferException):
_ _ """
 __ Raised_when_you want to put larger piece_then_the buffer max size.
   _"""
   _pass

############################################################################
############################################################################

class_StreamBuffer(object):
   _def __init__(self):
   _    self.size =_0 _#: current_size of the buffer
       _self.max_size = None
   _   _self.queue =_deque()
_  __ _ self.not_full_cond = threading.Condition()

   _############################################################

 _  def __del__(self):
  _   __self.clear()

    ############################################################

 _  def clear(self):
  _    _with_self.not_full_cond:
_    _     _self.queue.clear()
  _      __ self.size = 0
  __     ___self.not_full_cond.notify()

    ############################################################

_   def set_max_size(self, max_size):
_       """
 _  _   @param max_size:_None_or_number of bytes: L{StreamBuffer.put} will
     _ _  _         _ block if the content will be_bigger then C{max_size}.
        _       _     WARNING: there_must be only one_thread_inserting data at
    ____  _  _  _ _  _a time
_  __   """
        assert (max_size is None) or (max_size >_0)
     _  self.max_size = max_size

__  ################################################