semvec/pypi-packages huggingface dataset:
lodepy 0.0.1
Fully python multi-node automation project
Requires Python: >=3.7

# lodepy
lodepy is a Multi-node fully python automation tool. It is agentless and executes tasks over SSH.

# The concept
In a nutshell, lodepy serves a pretty simple task: execute ssh commands on servers to set them up.

With this comes a variety of somewhat neccessary functionalities that lodepy implements:
* Execute the commands (obviously) within well defined "Groups" of "Nodes"
* Create a well defined logging system to stream and monitor task execution
* Provide a clean wrapper / execution model to seamlessly run operations and comparisons on multiple results.

# Using lodepy
In it's current state the main interaction is going to be with the [Group](https://github.com/tkatchen/lodepy/blob/main/src/lodepy/groups/group.py) class and its subclasses (namely the [GroupReturn](https://github.com/tkatchen/lodepy/blob/main/src/lodepy/groups/group_return.py)).

1) Definining a group is quickly done with the use of `lodepy.import_group_txt(file: str) -> Dict[str, Group]`
   1) This is going to be in the format of:
      ```
      [group1]

      node1, 1.1.1.1
      node2, 1.1.1.2

      [group2]

      node3, 1.1.1.1
      node4, 1.1.1.1

      [group_name]
      node_name, ssh_ip
      ```
   2) Note, already created groups can be found in the `lodepy.data_store().groups`

2) Executing commands
   1) We can then execute a variety of Group commands. A series of these are listed as functions of Group.py.
   2) Some commands can be custom created. In this case you simply need to:
      1) Define the Task
      2) `<Group>.execute_task(<Task>(params))`

3) Using these resulting GroupReturn
   1) Filtering
      1) GroupReturns handle filtering in the such way:
          ```python
          group_return = GroupReturn()
          double_lt_5 = group_return * 2 < 5
          # double_lt_5 is going to be the GroupReturn filtered with only nodes doubled returning a value less than 5.
          ```
           1) Note, this also works with versioning. A command like git_version will be able to handle filtering such as `group_return > 1.0.*`
   2) Executing future commands
      1) GroupReturns are simply subclasses of a Group. They can exectue commands and function entirely similarly.
   3) Any operations available to the value class
      1) Group returns aim to be abtract enough that any of the commands it's value expects to handle, so can the GroupReturn


In total this is the entire functionality loop of lodepy. There is still more to cover (and to implement), but to expect: log handling / streaming results elsewhere, more configurability (error handling, execution tuning, etc.), a variety of builtin Tasks for common usecases and the ability to seamlessly create more Tasks (and recursively handle encapsuled tasks).
perfcount 1.0.1
Useful Python library for performance testing that contains multiple function decorators
Keywords: testing,performance,timing,timeout,debugger,acceptance

# PerfCount - a Python library used for performance testing

Install it with `pip install perfcount`.

There are multiple decorators included for testing in the library, including `perf.perf`, `perfcount.perf_ns`, `perfcount.shouldtake`, and `perfcount.timeout`. The `perfcount.time_this_program` module can be imported to time the program from the time of importing the `perfcount.time_this_program` module to interpreter exit.

The command `perftcount` can be used to measure execution time of a command. Ex. `perfcount python script.py`.