Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-03-25 01:39
📄 documentSignoffDemo.py # # documentSignoffDemo.py # # Example of a state machine modeling the state of a document in a document # control system, using named state transitions # import statemachine import documentsignoffstate print( "\n".join( t.__name__ for t in documentsignoffstate.DocumentRevisionState.transitions() ) ) class Document(documentsignoffstate.DocumentRevisionStateMixin): def __init__(self): self.initialize_state(documentsignoffstate.New) def run_demo(): import random doc = Document() print(doc) # begin editing document doc.create() print(doc) print(doc.state.description) while not isinstance(doc._state, documentsignoffstate.Approved): print("...submit") doc.submit() print(doc) print(doc.state.description) if random.randint(1, 10) > 3: print("...reject") doc.reject() else: print("...approve") doc.approve() print(doc) print(doc.state.description) doc.activate() print(doc) print(doc.state.description) if __name__ == "__main__": run_demo()	1.12 KB	2025-03-25 01:39
📄 documentsignoffstate.pystate # # documentsignoffstate.pystate # # state machine model of the states and associated behaviors and properties for each # different state of a document in a document control system # # example using named state transitions # This implements a state model for submitting, # approving, activating, and purging document # revisions in a document management system. # # The state model looks like: # # New # \| # \| (create) # \| # v # Editing ----------------------------------------------+ # \| ^ \| # \| \| \| # \| +----------+ \| # \| \| \| # \| (submit) \| \| (cancel) # \| \| (reject) \| # v \| \| # PendingApproval-+ \| # \| \| # \| (approve) \| # \| \| # v \| # Approved <--------------------------+ (deactivate) \| # \| \| \| \| # \| +--------------+ \| \| # \| \| (activate) \| \| # \| v \| \| # \| (retire) Active ----------+ \| # \| \| # v \| # Retired \| # \| \| # \| (purge) \| # \| \| # v \| # Deleted <---------------------------------------------+ # # # There is no behavior attached to these states, this is # just an example of a state machine with named transitions. # statemachine DocumentRevisionState: New -( create )-> Editing Editing -( cancel )-> Deleted Editing -( submit )-> PendingApproval PendingApproval -( reject )-> Editing PendingApproval -( approve )-> Approved Approved -( activate )-> Active Active -( deactivate )-> Approved Approved -( retire )-> Retired Retired -( purge )-> Deleted New.description = 'creating...' Editing.description = 'editing...' PendingApproval.description = 'reviewing...' Approved.description = 'approved/inactive...' Active.description = 'approved/active...' Deleted.description = 'deleted...' Retired.description = 'retired...'	2.81 KB	2025-03-25 01:39
📄 libraryBookDemo.py # # libraryBookDemo.py # # Simple statemachine demo, based on the state transitions given in librarybookstate.pystate # import statemachine import librarybookstate class Book(librarybookstate.BookStateMixin): def __init__(self): self.initialize_state(librarybookstate.New) class RestrictedBook(Book): def __init__(self): super().__init__() self._authorized_users = [] def authorize(self, name): self._authorized_users.append(name) # specialized checkout to check permission of user first def checkout(self, user=None): if user in self._authorized_users: super().checkout() else: raise Exception( "{} could not check out restricted book".format( user if user is not None else "anonymous" ) ) def run_demo(): book = Book() book.shelve() print(book) book.checkout() print(book) book.checkin() print(book) book.reserve() print(book) try: book.checkout() except librarybookstate.BookState.InvalidTransitionException as e: print(e) print("..cannot check out reserved book") book.release() print(book) book.checkout() print(book) print() restricted_book = RestrictedBook() restricted_book.authorize("BOB") restricted_book.restrict() print(restricted_book) for name in [None, "BILL", "BOB"]: try: restricted_book.checkout(name) except Exception as e: print(".." + str(e)) else: print("checkout to", name) print(restricted_book) restricted_book.checkin() print(restricted_book) if __name__ == "__main__": run_demo()	1.72 KB	2025-03-25 01:39
📄 librarybookstate.pystate # # librarybookstate.pystate # # This state machine models the state of books in a library. # statemachine BookState: New -(shelve)-> Available Available -(reserve)-> OnHold OnHold -(release)-> Available Available -(checkout)-> CheckedOut CheckedOut -(checkin)-> Available # add states for restricted books New -(restrict)-> Restricted Available -(restrict)-> Restricted Restricted -(release)-> Available Restricted -(checkout)-> CheckedOutRestricted CheckedOutRestricted -(checkin)-> Restricted	542 B	2025-03-25 01:39
📄 statemachine.py # stateMachine.py # # module to define .pystate import handler # # import imputil import keyword import sys import os import types import importlib import importlib.machinery from urllib.parse import urlparse DEBUG = False import pyparsing as pp # define basic exception for invalid state transitions - state machine classes will subclass to # define their own specific exception type class InvalidTransitionException(Exception): pass ident = pp.Word(pp.alphas + "_", pp.alphanums + "_$") # add parse-time condition to make sure we do not allow any Python keywords to be used as # statemachine identifiers def no_keywords_allowed(s, l, t): wd = t[0] return not keyword.iskeyword(wd) ident.addCondition( no_keywords_allowed, message="cannot use a Python keyword for state or transition identifier", ) stateTransition = ident("from_state") + "->" + ident("to_state") stateMachine = ( pp.Keyword("statemachine") + ident("name") + ":" + pp.OneOrMore(pp.Group(stateTransition))("transitions") ) namedStateTransition = ( ident("from_state") + "-(" + ident("transition") + ")->" + ident("to_state") ) namedStateMachine = ( pp.Keyword("statemachine") + ident("name") + ":" + pp.OneOrMore(pp.Group(namedStateTransition))("transitions") ) def expand_state_definition(source, loc, tokens): """ Parse action to convert statemachine to corresponding Python classes and methods """ indent = " " * (pp.col(loc, source) - 1) statedef = [] # build list of states states = set() fromTo = {} for tn in tokens.transitions: states.add(tn.from_state) states.add(tn.to_state) fromTo[tn.from_state] = tn.to_state # define base class for state classes baseStateClass = tokens.name statedef.extend( [ f"class {baseStateClass}(object):", " def __str__(self):", " return self.__class__.__name__", " @classmethod", " def states(cls):", " return list(cls.__subclasses__())", " def next_state(self):", " return self._next_state_class()", ] ) # define all state classes statedef.extend("class {}({}): pass".format(s, baseStateClass) for s in states) # define state->state transitions statedef.extend( "{}._next_state_class = {}".format(s, fromTo[s]) for s in states if s in fromTo ) statedef.extend( [ "class {baseStateClass}Mixin:".format(baseStateClass=baseStateClass), " def __init__(self):", " self._state = None", " def initialize_state(self, init_state):", " if issubclass(init_state, {baseStateClass}):".format( baseStateClass=baseStateClass ), " init_state = init_state()", " self._state = init_state", " @property", " def state(self):", " return self._state", " # get behavior/properties from current state", " def __getattr__(self, attrname):", " attr = getattr(self._state, attrname)", " return attr", " def __str__(self):", " return '{0}: {1}'.format(self.__class__.__name__, self._state)", ] ) return ("\n" + indent).join(statedef) + "\n" stateMachine.setParseAction(expand_state_definition) def expand_named_state_definition(source, loc, tokens): """ Parse action to convert statemachine with named transitions to corresponding Python classes and methods """ indent = " " * (pp.col(loc, source) - 1) statedef = [] # build list of states and transitions states = set() transitions = set() baseStateClass = tokens.name fromTo = {} for tn in tokens.transitions: states.add(tn.from_state) states.add(tn.to_state) transitions.add(tn.transition) if tn.from_state in fromTo: fromTo[tn.from_state][tn.transition] = tn.to_state else: fromTo[tn.from_state] = {tn.transition: tn.to_state} # add entries for terminal states for s in states: if s not in fromTo: fromTo[s] = {} # define state transition class statedef.extend( [ "class {baseStateClass}Transition:".format(baseStateClass=baseStateClass), " def __str__(self):", " return self.transitionName", ] ) statedef.extend( "{tn_name} = {baseStateClass}Transition()".format( tn_name=tn, baseStateClass=baseStateClass ) for tn in transitions ) statedef.extend( "{tn_name}.transitionName = '{tn_name}'".format(tn_name=tn) for tn in transitions ) # define base class for state classes statedef.extend( [ f"class {baseStateClass}(object):", " from statemachine import InvalidTransitionException as BaseTransitionException", " class InvalidTransitionException(BaseTransitionException): pass", " def __str__(self):", " return self.__class__.__name__", " @classmethod", " def states(cls):", " return list(cls.__subclasses__())", " @classmethod", " def next_state(cls, name):", " try:", " return cls.tnmap[name]()", " except KeyError:", " raise cls.InvalidTransitionException(f'{cls.__name__} does not support transition {name!r}'", " def __bad_tn(name):", " def _fn(cls):", " raise cls.InvalidTransitionException(f'{cls.__name__} does not support transition {name!r}'", " _fn.__name__ = name", " return _fn", ] ) # define default 'invalid transition' methods in base class, valid transitions will be implemented in subclasses statedef.extend( " {tn_name} = classmethod(__bad_tn({tn_name!r}))".format(tn_name=tn) for tn in transitions ) # define all state classes statedef.extend("class {}({}): pass".format(s, baseStateClass) for s in states) # define state transition methods for valid transitions from each state for s in states: trns = list(fromTo[s].items()) # statedef.append(f"{s}.tnmap = {{{', '.join('%s:%s' % tn for tn in trns)}}}") statedef.extend( f"{s}.{tn_} = classmethod(lambda cls: {to_}())" for tn_, to_ in trns ) statedef.extend( [ "{baseStateClass}.transitions = classmethod(lambda cls: [{transition_class_list}])".format( baseStateClass=baseStateClass, transition_class_list=", ".join( "cls.{}".format(tn) for tn in transitions ), ), "{baseStateClass}.transition_names = [tn.__name__ for tn in {baseStateClass}.transitions()]".format( baseStateClass=baseStateClass ), ] ) # define <state>Mixin class for application classes that delegate to the state statedef.extend( [ "class {baseStateClass}Mixin:".format(baseStateClass=baseStateClass), " def __init__(self):", " self._state = None", " def initialize_state(self, init_state):", " if issubclass(init_state, {baseStateClass}):".format( baseStateClass=baseStateClass ), " init_state = init_state()", " self._state = init_state", " @property", " def state(self):", " return self._state", " # get behavior/properties from current state", " def __getattr__(self, attrname):", " attr = getattr(self._state, attrname)", " return attr", " def __str__(self):", " return '{0}: {1}'.format(self.__class__.__name__, self._state)", ] ) # define transition methods to be delegated to the _state instance variable statedef.extend( " def {tn_name}(self): self._state = self._state.{tn_name}()".format( tn_name=tn ) for tn in transitions ) return ("\n" + indent).join(statedef) + "\n" namedStateMachine.setParseAction(expand_named_state_definition) # ====================================================================== # NEW STUFF - Matt Anderson, 2009-11-26 # ====================================================================== class SuffixImporter: """An importer designed using the mechanism defined in :pep:`302`. I read the PEP, and also used Doug Hellmann's PyMOTW article `Modules and Imports`_, as a pattern. .. _`Modules and Imports`: http://www.doughellmann.com/PyMOTW/sys/imports.html Define a subclass that specifies a :attr:`suffix` attribute, and implements a :meth:`process_filedata` method. Then call the classmethod :meth:`register` on your class to actually install it in the appropriate places in :mod:`sys`.""" scheme = "suffix" suffix = None path_entry = None @classmethod def trigger_url(cls): if cls.suffix is None: raise ValueError(f"{cls.__name__}.suffix is not set") return f"suffix:{cls.suffix}" @classmethod def register(cls): sys.path_hooks.append(cls) sys.path.append(cls.trigger_url()) def __init__(self, path_entry): pr = urlparse(str(path_entry)) if pr.scheme != self.scheme or pr.path != self.suffix: raise ImportError() self.path_entry = path_entry self._found = {} def checkpath_iter(self, fullname): for dirpath in sys.path: # if the value in sys.path_importer_cache is None, then this # path should be imported by the builtin mechanism, and the # entry is thus a path to a directory on the filesystem; # if it's not None, then some other importer is in charge, and # it probably isn't even a filesystem path finder = sys.path_importer_cache.get(dirpath) if isinstance(finder, (type(None), importlib.machinery.FileFinder)): checkpath = os.path.join(dirpath, "{}.{}".format(fullname, self.suffix)) yield checkpath def find_module(self, fullname, path=None): for checkpath in self.checkpath_iter(fullname): if os.path.isfile(checkpath): self._found[fullname] = checkpath return self return None def load_module(self, fullname): assert fullname in self._found if fullname in sys.modules: module = sys.modules[fullname] else: sys.modules[fullname] = module = types.ModuleType(fullname) data = None with open(self._found[fullname]) as f: data = f.read() module.__dict__.clear() module.__file__ = self._found[fullname] module.__name__ = fullname module.__loader__ = self self.process_filedata(module, data) return module def process_filedata(self, module, data): pass class PystateImporter(SuffixImporter): suffix = "pystate" def process_filedata(self, module, data): # MATT-NOTE: re-worked :func:`get_state_machine` # convert any statemachine expressions stateMachineExpr = (stateMachine \| namedStateMachine).ignore( pp.pythonStyleComment ) generated_code = stateMachineExpr.transformString(data) if DEBUG: print(generated_code) # compile code object from generated code # (strip trailing spaces and tabs, compile doesn't like # dangling whitespace) COMPILE_MODE = "exec" codeobj = compile(generated_code.rstrip(" \t"), module.__file__, COMPILE_MODE) exec(codeobj, module.__dict__) PystateImporter.register() if DEBUG: print("registered {!r} importer".format(PystateImporter.suffix))	12.1 KB	2025-03-25 01:39
📄 trafficLightDemo.py # # trafficLightDemo.py # # Example of a simple state machine modeling the state of a traffic light # import statemachine import trafficlightstate class TrafficLight(trafficlightstate.TrafficLightStateMixin): def __init__(self): self.initialize_state(trafficlightstate.Red) def change(self): self._state = self._state.next_state() light = TrafficLight() for i in range(10): print("{} {}".format(light, ("STOP", "GO")[light.cars_can_go])) light.crossing_signal() light.delay() print() light.change()	550 B	2025-03-25 01:39
📄 trafficlightstate.pystate # # trafficlightstate.pystate # # state machine model of the states and associated behaviors and properties for each # different state of a traffic light # define state machine with transitions # (states will be implemented as Python classes, so use name case appropriate for class names) statemachine TrafficLightState: Red -> Green Green -> Yellow Yellow -> Red # statemachine only defines the state->state transitions - actual behavior and properties # must be added separately # define some class level constants Red.cars_can_go = False Yellow.cars_can_go = True Green.cars_can_go = True # setup some class level methods def flash_crosswalk(s): def flash(): print(f"{s}...{s}...{s}") return flash Red.crossing_signal = staticmethod(flash_crosswalk("WALK")) Yellow.crossing_signal = staticmethod(flash_crosswalk("DONT WALK")) Green.crossing_signal = staticmethod(flash_crosswalk("DONT WALK")) # setup some instance methods def wait(nSeconds): def waitFn(self): print("<wait %d seconds>" % nSeconds) return waitFn Red.delay = wait(20) Yellow.delay = wait(3) Green.delay = wait(15)	1.11 KB	2025-03-25 01:39
📄 vending_machine.py # # vending_machine.py # # Example of using the statemachine parser without importing a .pystate module. # # A vending machine that dispenses candy and chips in a 4x4 grid, A1 thru D4. # To dispense a product, you must press an alpha button, then a digit button. # import statemachine # Vending machine buttons: # A, B, C, D # 1, 2, 3, 4 # vending_machine_state_description = """\ statemachine VendingMachineState: Idle-(press_alpha_button)->WaitingOnDigit WaitingOnDigit-(press_alpha_button)->WaitingOnDigit WaitingOnDigit-(press_digit_button)->DispenseProduct DispenseProduct-(dispense)->Idle """ # convert state machine text to state classes generated = statemachine.namedStateMachine.transformString( vending_machine_state_description ) # print(generated) # exec generated code to define state classes and state mixin exec(generated) class VendingMachine(VendingMachineStateMixin): def __init__(self): self.initialize_state(Idle) self._pressed = None self._alpha_pressed = None self._digit_pressed = None def press_button(self, button): if button in "ABCD": self._pressed = button self.press_alpha_button() elif button in "1234": self._pressed = button self.press_digit_button() else: print("Did not recognize button {!r}".format(str(button))) def press_alpha_button(self): try: super().press_alpha_button() except VendingMachineState.InvalidTransitionException as ite: print(ite) else: self._alpha_pressed = self._pressed def press_digit_button(self): try: super().press_digit_button() except VendingMachineState.InvalidTransitionException as ite: print(ite) else: self._digit_pressed = self._pressed self.dispense() def dispense(self): try: super().dispense() except VendingMachineState.InvalidTransitionException as ite: print(ite) else: print("Dispensing at {}{}".format(self._alpha_pressed, self._digit_pressed)) self._alpha_pressed = self._digit_pressed = None vm = VendingMachine() for button in "1 A B 1".split(): print(">> pressing {!r}".format(button)) vm.press_button(button) print("Vending machine is now in {} state".format(vm.state))	2.38 KB	2025-03-25 01:39
📄 video_demo.py # # video_demo.py # # Simple statemachine demo, based on the state transitions given in videostate.pystate # import statemachine import videostate class Video(videostate.VideoStateMixin): def __init__(self, title): self.initialize_state(videostate.Stopped) self.title = title # ==== main loop - a REPL ==== v = Video("Die Hard.mp4") while True: print(v.state) cmd = ( input("Command ({})> ".format("/".join(videostate.VideoState.transition_names))) .lower() .strip() ) if not cmd: continue if cmd in ("?", "h", "help"): print("enter a transition {!r}".format(videostate.VideoState.transition_names)) print(" q - quit") print(" ?, h, help - this message") continue # quitting out if cmd.startswith("q"): break # get transition function for given command state_transition_fn = getattr(v, cmd, None) if state_transition_fn is None: print("???") continue # invoke the input transition, handle invalid commands try: state_transition_fn() except videostate.VideoState.InvalidTransitionException as e: print(e)	1.16 KB	2025-03-25 01:39
📄 videostate.pystate # # videostate.pystate # # Statemachine describing the playing of a video # [] = stop # > = play # \|\| = pause # >> = fast forward # << = rewind statemachine VideoState: # basic >, [], and \|\| controls Stopped-(play)->Playing Playing-(pause)-> Paused Playing-(stop)-> Stopped Paused-(stop)-> Stopped Paused-(play)->Playing # add >> and << controls - different meanings if occur while playing or stopped Playing-(fast_forward)->FastForward FastForward-(play)->Playing FastForward-(pause)->Paused FastForward-(stop)->Stopped Stopped-(fast_forward)->Forwardwinding Forwardwinding-(stop)->Stopped Playing-(rewind)->ReversePlaying ReversePlaying-(play)->Playing ReversePlaying-(pause)->Paused ReversePlaying-(stop)->Stopped Stopped-(rewind)->Rewinding Rewinding-(stop)->Stopped	861 B	2025-03-25 01:39

Terminal