semvec/pypi-packages huggingface dataset:
nomad-camels-driver-thorlabs-K10CR1 0.1.2
Instrument driver for the Thorlabs K10CR1 rotation mount for NOMAD-CAMELS
Requires Python: >=3.9.6

# NOMAD-CAMELS Driver for Thorlabs K10CR1

Driver for the Thorlabs K10CR1 motorized rotation mount written for the measurement software [NOMAD-CAMELS](https://fau-lap.github.io/NOMAD-CAMELS/).


## Features
The position can be set and read, together with acceleration and maximum velocity.


## Documentation

For more information visit the [documentation](https://fau-lap.github.io/NOMAD-CAMELS/doc/instruments/instruments.html).
nomad-camels-driver-thorlabs-MFF 0.1.1
Instrument driver for Thorlabs motorized flip mounts for NOMAD-CAMELS
Requires Python: >=3.9.6

# NOMAD-CAMELS Driver for Thorlabs MFF

Driver for the Thorlabs MFF motorized filter flip mount written for the measurement software [NOMAD-CAMELS](https://fau-lap.github.io/NOMAD-CAMELS/).


## Features
The position can be set and read, together with transit time.


## Documentation

For more information visit the [documentation](https://fau-lap.github.io/NOMAD-CAMELS/doc/instruments/instruments.html).
nomad-camels-driver-thorlabs-TLPM 0.1.1
Instrument driver for Thorlabs powermeters for NOMAD-CAMELS
Requires Python: >=3.9.6

# NOMAD-CAMELS Driver for Thorlabs TLPM

Driver for Thorlabs USB power-meters written for the measurement software [NOMAD-CAMELS](https://fau-lap.github.io/NOMAD-CAMELS/).

## Installation
To use this driver, files from Thorlabs are needed. You can download the software provided by Thorlabs on [their website](https://www.thorlabs.com/software_pages/ViewSoftwarePage.cfm?Code=OPM). If the driver does not work right away after installing the software, locate the files "TLPM.py" and "TLPM_64.dll" and copy them to driver's directory. Make sure you use the TLPM drivers in the Thorlabs Driver Switcher.

## Features
The wavelength can be set and the power can be read.


## Documentation

For more information visit the [documentation](https://fau-lap.github.io/NOMAD-CAMELS/doc/instruments/instruments.html).
pulsed-squeezing 0.1.0
Theoretical models and visualization tools for pulsed squeezed light
Requires Python: >=3.9

# Pulsed Squeezing Simulator

This repository contains a Python simulation framework for **pulsed squeezed light**. It provides theoretical models and example notebooks to explore squeezing in 1D cavities.

---

## Repository Structure

- `theoretical_pulsed.py` — Python file containing 3 main classes  
- `tutorial-notebook.ipynb` — Tutorial notebook demonstrating usage  
- `main-notebook.ipynb` — Main notebook that explains the theory and gives some results interpretation 
- `pyproject.toml` — UV app project configuration for dependencies  
- `uv.lock` — UV lock file to ensure reproducible installs  
- `README.md` — This file  

---

## Classes

All main functionality is implemented in `theoretical_pulsed.py`:

- **TheoreticalPulsedSqueezing** — [Simulate pulsed squeezing in an optical cavity with various input pulse shapes.]  
- **TheoreticalPulsed1D** — [1D parameter sweep for pulsed squeezing simulations.]  
- **PulsedSqueezingVisualizer** — [Visualizer for pulsed squeezing simulations with various pulse shapes.]  

---

## Notebooks

- **`tutorial-notebook.ipynb`** — Step-by-step tutorial showing how to use the classes for simulations.  

---

## Installation

The project uses **UV** to manage Python dependencies. `pyproject.toml` and `uv.lock` define the required packages.
predictasearch 1.0.1
Python library and command-line utility for Predicta Search API
Requires Python: >=3.8

# predictasearch: The official Python library and CLI for Predicta Search
predictasearch is a Python library that interacts with the PredictaSearch API to perform searches on emails and phone numbers, as well as retrieve the list of supported networks.

## Features
- Search by email address
- Search by phone number
- Search by name
- Search by username
- Retrieve the list of supported networks

## Quick Start
```bash
import os
from predictasearch import PredictaSearch

client = PredictaSearch(api_key=os.environ["PREDICTA_API_KEY"])

networks = client.get_supported_networks()
print(networks)

email_results = client.search_by_email("example@email.com")
print(email_results)

phone_results = client.search_by_phone("+33612345678")
print(phone_results)

name_results = client.search_by_name("John Doe")
print(name_results)

username_results = client.search_by_username("Johndoe")
print(username_results)
```
Grab your API key from https://www.predictasearch.com/

## Installation
To install the Predicta Search library, simply:
```bash
pip install predictasearch
```

## Documentation
Documentation is available at https://dev.predictasearch.com/redoc
nomad-camels-driver-trinamic-tmcm-1110 0.1.1
Instrument driver for Trinamic TMCM 1110 for NOMAD-CAMELS
Requires Python: >=3.9.6

# NOMAD-CAMELS Driver for Trinamic TMCM 1110

Driver for the TMCM 1110 control board by Trinamic written for the measurement software [NOMAD-CAMELS](https://fau-lap.github.io/NOMAD-CAMELS/).

## Features
Setting and reading the steppers position. Support of different reference search modes, setting of acceleration and velocity.


## Documentation

For more information visit the [documentation](https://fau-lap.github.io/NOMAD-CAMELS/doc/instruments/instruments.html).
pysimmods 1.0.0
A set of simulation models representing different distributed consumer or generator units.
Requires Python: >=3.10

# Pysimmods

This projects contains a collection of (python) simulation models for a variety of energy generation and consumption units. Most of the models were originally developed in the context of the research project iHEM (intelligent Home Energy Management) or other projects at OFFIS. Other models were developed during a student project group at the University of Oldenburg. The models are intended to be used with the co-simulation framework mosaik (https://mosaik.offis.de), but are also usable without mosaik.

Version: 1.0

License: LGPL

## Installation

Pysimmods requires Python >= 3.10 and is available on https://pypi.org. 
It can be installed, preferably into a virtualenv,  with 

    >>> pip install pysimmods

Alternatively, you can clone this repository with

    >>> git clone https://gitlab.com/midas-mosaik/pysimmods.git

then switch into the pysimmods folder and type

    >>> pip install -e .

## Documentation

You will find a still growing documentation at https://midas-mosaik.gitlab.io/pysimmods.
Please create an issue if you find any errors or if you think that something should be explained more explicitly.
midas-weather 2.1.0
A Midas module for weather datasets.
Requires Python: >=3.10

# Midas Weather

## Description

This package contains a midas module providing a simulator for weather data.

Although this package is intendet to be used with midas, it can be use it in any mosaik simulation scenario.

## Installation

This package will usually be installed automatically together with `midas-mosaik` if you opt-in for the `base` extra.
It is available on pypi, you can install it manually with 

```bash
pip install midas-weather
```

## Usage

The complete documentation is available at https://midas-mosaik.gitlab.io/midas.

### Inside of midas

To use the weather data inside of midas, add `weather` to your modules

```yaml
my_scenario:
  modules:
    - weather
    - ...
```

and configure it with

```yaml
  weather_params:
    my_weather_scope:
      weather_mapping:
        WeatherCurrent:
          - interpolate: true
            randomize: true
```

If a store module is enabled, the weather module will automatically send all outputs to the store.


### Any mosaik scenario

If you don't use midas, you can add the `weather` manually to your mosaik scenario file.
First, the entry in the `sim_config`:

```python
sim_config = {
    "WeatherData": {"python": "midas_weather.simulator:WeatherDataSimulator"},
    # ...
}
```

Next, you need to define `start_date` and `step_size`.
The `start_date` is to be provided as ISO datestring and can anything between 2009 and 2022:

```python
start_date = "2021-06-08 14:00:00+0000"
```

The `step_size` can be anything between 1 and 3600. 
Higher values might be possible, but this is untested.

Now, the simulator can be started:

```python
weather_sim = world.start("WeatherData", step_size=900, start_date=start_date)
```

Next, a weather data model can be started:

```python
weather_model = weather_sim.WeatherCurrent(interpolate=True, randomize=True)

```

Finally, the model needs to be connected to other models:

```python
world.connect(weather_model, other_entity, "t_air_deg_celsius", "wind_v_m_per_s")
```

## License

This software is released under the GNU Lesser General Public License (LGPL). 
See the license file for more information about the details.
midas-store 2.1.0
A database simulator that stores every input.
Requires Python: >=3.10

# Midas Store

## Description

This package contains a midas module providing a database simulator. 
This works like most other collectors for mosaik, i.e., it accepts any number of inputs and stores them in a database file.

Although this package is intended to be used with midas, you can use in any mosaik simulation scenario.

Version: 2.1

## Installation

This package will usually installed automatically together with `midas-mosaik` if you opt-in any of the extras, e.g., `base` or `bh`. 
It is available on pypi, so you can install it manually with

```bash
pip install midas-store
```

## Usage

The complete documentation is available at https://midas-mosaik.gitlab.io/midas.

### Inside of midas

To use the store inside of midas, just add `store` to your modules

```yaml
my_scenario:
  modules:
    - store
    - ...
```

and configure it with (`filename` is required, everything else is optional and can be left out if the default values, shown below, are used):

```yaml
  store_params:
    filename: my_results.csv
    step_size: 900
    unique_filename: False
    keep_old_files: False
```

All simulators that have something to store will then automatically connect to the `store` simulator.

### Any mosaik scenario

If you don't use midas, you can add the `store` manually to your mosaik scenario file. 
First, the entry in the `sim_config`:

```python
sim_config = {
    "MidasCSV": {"python": "midas_store.simulator:MidasCSVStore"},
    # ...
}
```

Next, you need to start the simulator (assuming a `step_size` of 900):

```python
store_sim = world.start("MidasCSVStore", step_size=900)
```

Finally, the model needs to be started:

```python
store = store_sim.Database(filename="my_results.csv", keep_old_files=False, unique_filename=False)
```

Afterwards, you can define `world.connect(other_entity, store, attrs)` as you like.

## License

This software is released under the GNU Lesser General Public License (LGPL). See the license file for more information about the details.
midas-sndata 2.1.0
A Midas module for the Smart Nord dataset.
Requires Python: >=3.10

# Midas Smart Nord Data Simulator

This package contains a midas module providing a simulator for the Smart Nord data set. 
Although this package is intended to be used with midas, it can be used in any mosaik simulation scenario.

Version: 2.1

## Installation

This package will usually installed automatically together with `midas-mosaik` if you opt-in for the `base` extra. 
It is available on pypi, so you can install it manually with

```bash
pip install midas-sndata
```

## Usage

The complete documentation is available at https://midas-mosaik.gitlab.io/midas.

### Inside of midas
To use the powergrid inside of midas, just add `sndata` to your modules

```yaml
my_scenario:
  modules:
    - sndata
    - ...
```

and configure it with:

```yaml
  sndata_params:
    my_grid_scope:
      step_size: 900  # <-- Default value
      grid_name: my_grid_scope
      active_mapping: 
        1: [[Land_0, 1.0], [Land_2, 1.5]]
        3: [[House_000, 1.0]]
```

The mapping has to match to the grid that you're using.

### Any mosaik scenario

If you don't use midas, you can add the `sndata` manually to your mosaik scenario file. 
First, the entry in the `sim_config`:

```python
  sim_config = {
    "SmartNordData": {
      "python": "midas_smartnord.simulator:SmartNordDataSimulator"
    },
    # ...
  }
```

Next, you need to start the simulator (assuming a `step_size` of 900):

```python
  sndata_sim = world.start(
      "SmartNordData",
      step_size=900,
      start_date="2020-01-01 00:00:00+0100",
      data_path="/path/to/folder/where/dataset/is/located/",
      filename="smart_nord_profiles.csv",  # this is default
  )
```

Then the models can be started:

```python
  land1 = sndata_sim.CalculatedQTimeSeries(name="Land_0", scaling=1.0)
  land2 = sndata_sim.CalculatedQTimeSeries(name="Land_2", scaling=1.5)
  house1 = sndata_sim.CalculatedQTimeSeries(name="House_000", scaling=1.0)
```

Finally, the modells need to be connected to other entities:

```python
  world.connect(land1, other_entity, "p_mw", "q_mvar")
```

## License

This software is released under the GNU Lesser General Public License (LGPL). 
See the license file for more information about the details.

The data set is a result from the research project [Smart Nord](www.smartnord.de).
midas-sbdata 2.1.0
A Midas module for Simbench dataset.
Requires Python: >=3.10

# MIDAS Simbench Data Simulator

The *sbdata* module, provided by the *midas-sbdata* package, provides a simulator for simbench data sets even outside of simbench networks.

Version: 2.1


## Installation

This package will be installed automatically with `midas-mosaik` if you opt-in the `full` extra. 
It is available on pypi, so you can install it manually with

```bash
pip install midas-sbdata
```

## Usage

The complete documentation is available at https://midas-mosaik.gitlab.io/midas.

### Inside of MIDAS

To use the simulator inside of midas, add `sbdata` to your modules:

```yaml
my_scenario:
  modules:
    - sbdata
    - ...
```

and configure it with:

```yaml
    my_scenario:
      # ...
      sndata_params:
        my_grid_scope:
          is_load: false
          is_sgen: false
          combined_mapping:
            1: [[[load_000_p_mw, load_000_q_mvar], 1.0]]
            3: [[sgen_000_p_mw, 1.0]]
```

### Any mosaik scenario

If you don't use midas, you can add the `sbdata` manually to your [mosaik scenario](https://mosaik.readthedocs.io/en/latest/tutorials/demo1.html) file.
First, the entry in the `sim_config`:


```python
    sim_config: {
      "SimbenchData": {
        "python": "midas_powerseries.simulator:PowerSeriesSimulator",
      }
    }
```

Next, you need to start the simulator (assuming a `step_size` of 900):

```python
    sbdata_sim = world.start(
        "SimbenchData",
        step_size=900,
        is_load=False,
        is_sgen=False,
        start_date="2020-01-01 00:00:00+0100",
        data_path="/path/to/folder/where/dataset/is/located",
        filename="1-LV-rural3--0-sw.csv",  # this is default,
    )
```

Then the models can be started:

```python
    load1 = sbdata_sim.CombindTimeSeries(name=["load_000_p_mw", "load_000_q_mvar"], scaling=1.0)
    sgen1 = sbdata_sim.CalculatedQTimeSeries(name="sgen_000_p_mw", scaling=1.0)
```

Finally, the models need to be connected to other entities:

```python
    world.connect(load1, other_entity, "p_mw", "q_mvar")
```

## License

This software is released under the GNU Lesser General Public License (LGPL). See the license file for more information about the details.
midas-pwdata 2.1.0
A Midas module for pv and wind datasets.
Requires Python: >=3.10

# Midas PV and Wind Data Simulator

The *pwdata* module, provided by the *midas-pwdata* package, provides a simulator for PV and wind time series.

Version: 2.1

## Installation


This package will usually installed automatically together with `midas-mosaik`,
if you opt-in the `bh` extra. It is available on pypi, so you can install it
manually with

```bash
    pip install midas-pwdata
```

## Usage

The intended use-case for the time simulator is to be used inside of midas.
However, it can be used in any mosaik simulation scenario.

### Inside of midas


To use the pwdata inside of midas, simply add `pwdata` to your modules

```yaml
    my_scenario:
      modules:
        - pwdata
        # - ...
```

and provide a *scope* and a configuration:

```yaml
    my_scenario:
      # ...
      pwdata_params:
        my_grid_scope:
          interpolate: True
          randomize_data: True
          randomize_cos_phi: True
          active_mapping:
            16: [[onshore_p_mw, 5]]
            17: [[solar_p_mw, 0.03]]
            20: [[solar_p_mw, 0.41]]
```

The mapping has to match to the grid that you're using.

### Any Mosaik Scenario

If you don't use midas, you can add the `pwdata` manually to your
`mosaik scenario`_ file. First, the entry in the `sim_config`:

```python
    sim_config = {
        "PVWindData": {"python": "midas_powerseries.simulator:PowerSeriesSimulator"},
        # ...
    }
```

Next, you need to start the simulator (assuming a `step_size` of 900):

```python
    pw_sim = world.start(
        "PVWindData",
        step_size=900,
        data_step_size=3600,
        is_load=False,
        is_sgen=True,
        start_date="2020-01-01 00:00:00+0100",
        data_path="/path/to/folder/where/dataset/is/located/",
        filename="pvwind_profiles.csv",  # this is default
    )
```

Then the models can be started:

```python
    wind = pw_sim.CalculatedQTimeSeries(name="on_shore_p_mw", scaling=5)
    pv1 = pw_sim.CalculatedQTimeSeries(name="solar_p_mw", scaling=0.03)
    pv2 = pw_sim.CalculatedQTimeSeries(name="solar_p_mw", scaling=0.41)
```

Finally, the modells need to be connected to other entities:

```python
    world.connect(wind, other_entity, "p_mw", "q_mvar")
```

## License

The data set is taken from [50Hertz](https://www.50hertz.com/en/).
midas-powerseries 2.1.0
A MIDAS module for a electrical power timeseries simulator.
Requires Python: >=3.10

# Midas PowerSeries

The midas power series module is a general purpose data simulator, currently focussed on csv files.

Although this package is intended to be used with midas, it can be used in any mosaik simulation scenario.

Version: 2.1

## Installation

This package will usually be installed automatically by most of the other data simulators from midas. 
It is available on pypi, so you can install it manually with

```bash
pip install midas-powerseries
```

## Usage

The complete documentation is available at https://midas-mosaik.gitlab.io/midas.

### Inside of midas

There are already a few data simulators for specific data sets that can be used instead of this simulator.
However, if you have a csv file with time series and want to use it in a midas scenario, you have to add `powerseries` to your modules

```yaml
my_scenario:
  modules:
    - powerseries
    - ...
```

The configuration needs to provide the path to your csv file and how the data should be connected to the power grid.

```yaml
  powerseries_params:
    my_grid_scope:
      step_size: 900  # <-- Default value
      data_path: "path/to/folder/containing/csv/file"
      filename: "my_time_series.csv"
      data_step_size: 900  # <-- Default value
      data_scaling: 1.0  # Default value; use it if your data is, e.g., in kW instead of MW
      meta_scaling: 1.0  # Default value; use it to scale all of the time series globally
      active_mapping:
        0: [[load_01_p_mw, 1.0], [load_02_p_mw], 1.2]  # load_01_p_mw and load_02_p_mw have to be column names in the csv file
```

### Any mosaik scenario

tbd

## License

This software is released under the GNU Lesser General Public License (LGPL). 
See the license file for more information about the details.
midas-powergrid 2.1.0
A simulator for pandapower grids.
Requires Python: >=3.10

# Midas Powergrid Simulator

This package contains a Midas module providing a pandapower simulator and a number of custom powergrids.

Although this package is intended to be used with midas, but you can use in any mosaik simulation scenario.

Version: 2.1

## Installation

This package will usually installed automatically together with `midas-mosaik` if you opt-in any of the extras, e.g., `base` or `bh`. 
It is available on pypi, so you can install it manually with

```bash
pip install midas-powergrid
```

## Usage

The complete documentation is available at https://midas-mosaik.gitlab.io/midas.

### Inside of midas

To use the powergrid inside of midas, just add `powergrid` to your modules

```yaml
my_scenario:
  modules:
    - powergrid
    - ...
```

and configure it with (`gridfile` is required, everything else is optional and can be left out if the default values, shown below, are used):


```yaml
  powergrid_params:
    my_grid_scope:
      gridfile: midasmv
      grid_params: {}
      step_size: 900
      plotting: False
      plot_path: _plots # Output path defined in runtime config
      save_grid_json: False
```

All simulators that want to connect to this grid, will have to use `my_grid_scope` as their `grid_name` value. 
Activating the plotting will results in a considerably longer execution time. 
Activate it only if you really need this feature and it does not work for all of the grids.

The gridfile can be either a path to a .json or .xlsx file, a simbench grid code, one of `cigre_hv`, `cigre_mv`, `cigre_lv`, `midasmv`, `midaslv`, or `bhv`, or an import path to a function or class that either returns a valid pandapower grid or is a pandapower grid itself. 
The `grid_params` can be used to pass keywork arguments to custom grids.

### Any mosaik scenario

If you don't use midas, you can add the `powergrid` manually to your mosaik scenario file. 
First, the entry in the `sim_config`:

```python
sim_config = {
    "Powergrid": {"python": "midas_powergrid.simulator:PandapowerSimulator"},
    # ...
}
```

Next, you need to start the simulator (assuming a `step_size` of 900):

```python
powergrid_sim = world.start("Powergrid", step_size=900)
```

Finally, the model needs to be started:

```python
powergrid = powergrid_sim.Grid(gridfile="midasmv", grid_params={})
```

To connect the output of the grids' buses to another model, you have to get the list of bus models from the powergrids' children like

```python
bus_models = [e for e in powergrid.children if "bus" in e.eid]
```

and then connect those models either individually or in a loop, e.g.,

```python
for bus in bus_models:
    world.connect(bus, other_entity, "vm_pu", "va_degree", "p_mw", "q_mvar")
```

The inputs are generally handled in the same way. 
Have a look at `powergrid.children` to get the required entity eids.

## License
This software is released under the GNU Lesser General Public License (LGPL). See the license file for more information about the details.