semvec/pypi-packages huggingface dataset:
larpix-daq 0.2.1
LArPix DAQ system
Keywords: dune larpix

# larpix-daq

[![Documentation
Status](https://readthedocs.org/projects/larpix-daq/badge/?version=stable)](https://larpix-daq.readthedocs.io/en/stable/?badge=stable)

LArPix DAQ is the data acquisition system for LArPix. It handles the
data flow between the "data boards" and offline storage and includes
data monitoring and operator control functionality built on the xylem
DAQ framework.

LArPix DAQ consists of a set of scripts which are responsible for
individual parts of the DAQ system's functionality, as well as an
operator interface API which can be run in an interactive python session
or used as a basis for a more sophisticated interactive program. The
scripts can be run from the same or from different computers, as long as
the IP addresses of the various computers are known.


### System states

There are three states the system can be in: ``READY``, ``RUN``, and
``STOP``. The state is controlled through the ``Operator`` object using
the methods ``prepare_run`` (transition to ``READY``), ``begin_run``
(transition to ``START``), and ``end_run`` (transition to ``STOP``).

- ``STOP``: Default state on startup. All components are not expecting
  data.
- ``READY``: Components should prepare to receive data. Data may arrive
  at the component before the instruction to transition to the ``RUN``
  state (though this is expected to be rare). The component should treat
  that data as if it were received in the ``RUN`` state.
- ``RUN``: Components should expect to receive data. Data should not be
  produced in any other state.

To mark the start and end of a run in the data flow, the ``producer.py`` script
produces ``INFO`` messages with contents ``"Beginning run"`` and
``"Ending run"``, respectively.


## Operator

The LArPix DAQ Operator module provides the interface into the DAQ core
for all DAQ operations.

Operator methods interact with the DAQ core to accomplish the
desired behavior. For the simplest interactions, a single request
and response exchange occurs, and the result is returned.
(TODO!!! unify this interface) For most interactions, there are
multiple responses for a single request - e.g. an immediate
acknowledgement of receipt and then the eventual result. The
methods implementing these interactions return [generator
iterators](https://docs.python.org/3/glossary.html#term-generator)
rather than values. The way to call these functions usually looks like

```python
o = Operator()
final_responses = []
for response in o.run_routine('example'):
    print(response)
    # interact with response object within loop
# When the loop ends, the last response received is still saved in
# the response object
final_responses.append(response)
```
purephotonicscontrol 0.0.0
A package to control PurePhotonics lasers

# purephotonicscontrol

A python package to easily communicate with PurePhotonics lasers through python. 
Most purephotonics features are implemented, so the user can create their own computer controlled laser sequence.
The package has been developed for the PPCL560 laser, but should generalise.

The code assume that the PPCL560 laser is interfaced with a Teensy 3.6 as outlined in(TO DO!). This interface is useful for creating trigger-able signals from the laser.
When the laser to connected to a PC directly, do this (TO DO!)

## Getting Started

Run the examples on the git
TO DO: Add details on connecting PC to laser

### Prerequisites

Python3, a laser


### Installing


```
pip install purephotonicscontrol
```


TO DO: End with an example of getting some data out of the system or using it for a little demo


## Contributing

TO DO


## Authors

* **Matthew Berrington**  - [bitbucket profile](https://bitbucket.org/matthewberrington)

## License

The MIT License

## Acknowledgments

* Thanks to PurePhotonics for provided a python example which seeded this project
hostparse 0.0.6
A command-line client for URL and hostname swizzling

# hostparse
`hostparse` - A command-line client for URL and hostname swizzling

## Installation
`hostparse` can be installed manually by cloning this repository, going to the main directory and typing:

```
pip install .
```

Or it can be installed using PyPI:

```
pip install hostparse
```

## Usage
`hostparse` installs as a commandline utility and takes input from stdin. In essence hostparse has a few simple parseable items it can extract from a URL. This is the full list of items:

* scheme
* username
* password
* subdomain
* domain
* hostname
* tld
* port
* path
* params
* query
* fragment

These items can be used as 'swizzling' operators seperated by a comma (`,`). For example, lets say the input contains a url from which you want to extract just the registered domain with its tld you can do:

```
hostparse domain,tld
```

Now what is neat with these items is that the tool will match the shortest match without duplicates. This means that instead of typing `tld` you can also type `tl` or even `t` as there are no other items that would conflict. The same query as before can also be written as:

```
hostparse d,t
```

The only thing to be careful of is the match, for example you can't use `p` for `port` as it will also match other items (the tool will warn you about this and simply return without processing data). You have to get the right match, `po` will work for `ports` however `pa` won't work woth `path` as it will also match `params` which means you have to use `pat` for path.

Additionally the data the tool outputs uses a delimiter based on the items you choose, so if you choose `domain` and `tld` it will be outputed as: `<domain>.<tld>`. You can change this delimiter value with the `-d` operator after you specify the items to filter out. If you don't want a delimiter you can specify it as `-d''`.

One extra thing to point out: the order of the items you specify is also how they are represented in the output.

## Bugs & Features

Feel free to open issues for features or bugs you've found or do a pull request and you will be rewarded somewhere later in life for it.