semvec/pypi-packages huggingface dataset:
mirar 1.1.0
Modular Image Reduction and Analysis Resource (MIRAR)
Requires Python: <4,>=3.10


![alt text](docs/source/MIRAR_logo.png?raw=true)

# Modular Image Reduction and Analysis Resource (MIRAR)

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10888436.svg)](https://doi.org/10.5281/zenodo.10888436)
[![PyPI version](https://badge.fury.io/py/mirar.svg)](https://badge.fury.io/py/mirar)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![CI](https://github.com/winter-telescope/mirar/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/winter-telescope/mirar/actions/workflows/continuous_integration.yml)
[![Coverage Status](https://coveralls.io/repos/github/winter-telescope/mirar/badge.svg?branch=main)](https://coveralls.io/github/winter-telescope/mirar?branch=main)
[![Documentation Status](https://readthedocs.org/projects/mirar/badge/?version=latest)](https://mirar.readthedocs.io/en/latest/?badge=latest)

Open-source modular python package for astronomy image reduction, created by [@robertdstein](https://github.com/robertdstein) and [@virajkaram](https://github.com/virajkaram).

Check out our [documentation](https://mirar.readthedocs.io/en/latest/?badge=latest) to learn more.

If you use MIRAR in your research, please cite the software using the Zenodo DOI/auto-generated reference: [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10888436.svg)](https://doi.org/10.5281/zenodo.10888436)
minigst 0.1.2
Wrapper package for gstlearn - Python version
Requires Python: >=3.8

# minigst (Python)

The companion Python package for gstlearn.

This Python package wraps gstlearn functions to offer access to some basic geostatistical methods (mainly variography and kriging).

## Installation

### Prerequisites

You need Python 3.8 or higher. You will also need to install the gstlearn Python package. Please refer to the [gstlearn documentation](https://gstlearn.org) for installation instructions.


### Installing minigst from our pypi (official release)

You can install the official release of minigst package using pip:

```bash
cd python
pip install minigst
```


### Installing minigst from sources

After cloning the github repo, you can install the minigst package from source using pip:

```bash
git clone https://github.com/gstlearn/minigst
cd minigst
cd python
pip install .
```

Or for development:

```bash
git clone https://github.com/gstlearn/minigst
cd minigst
cd python
pip install -e .
```

## Usage

```python
import minigst as mg
import gstlearn as gl
import pandas as pd

# Load data from a pandas DataFrame
df = pd.read_csv("data.csv")
db = mg.df_to_db(df, coord_names=["x", "y"])

# Compute experimental variogram
vario_exp = mg.vario_exp(db, vname="variable", nlag=20, dlag=10.0)

# Fit a model
model = mg.model_fit(vario_exp, struct=["NUGGET", "SPHERICAL"])

# Perform kriging
target_db = mg.create_db_grid(nx=[100, 100], dx=[1.0, 1.0])
mg.minikriging(db, target_db, vname="variable", model=model)

# Plot results
mg.dbplot_grid(target_db, color="K.variable.estim")
```

## Features

The minigst Python package provides wrapper functions for:

- **Database operations**: Convert pandas DataFrames to gstlearn Db objects, create grids, manipulate variables
- **Plotting**: Visualize spatial data and grids using matplotlib
- **Variography**: Compute experimental variograms and fit models
- **Kriging**: Perform simple, ordinary, and universal kriging
- **Simulation**: Generate Gaussian random fields

## Documentation

For more information about the underlying gstlearn library, please visit [gstlearn.org](https://gstlearn.org).

## License

This package is distributed under the BSD-3 license.
TkEngine-TheRealGrr 0.1
A game development engine
Requires Python: >=3.8

**TkEngine**

===

**PURPOSE**

---



**The game development engine designed especially for the Establish game.
But it may be used in other projects.**



**LICENSE**

---


**The TkEngine itself is fully open-source (Unlicense), while OpenGL and PyOpenGL are LICENSED under Apache License.
See NOTICE.**



**COMMANDS**

---


**All class and function names in TkEngine are written in CamelCase. There are special commands for using to interact with certain objects (see $cast.txt).**



**FUNCTIONS**

---


**All functions used in classes must accept and return archetype dictionary used for interaction with other functions or classes.
See src/examples.py**
essnmx 26.1.0
Data reduction for NMX at the European Spallation Source.
Requires Python: >=3.11

[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
[![PyPI badge](http://img.shields.io/pypi/v/essnmx.svg)](https://pypi.python.org/pypi/essnmx)
[![Anaconda-Server Badge](https://anaconda.org/conda-forge/essnmx/badges/version.svg)](https://anaconda.org/conda-forge/essnmx)
[![License: BSD 3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)

# ESSnmx

## About

Data reduction for NMX at the European Spallation Source.

## Installation

```sh
python -m pip install essnmx
```
linton 1.9.1
Simple standalone static web site builder using Markdown
Requires Python: >=3.13

# Linton

![logo](logo/linton.svg)

Reuben Thomas (rrt@sc3d.org)

Linton is a simple web site builder that converts a tree of Markdown files
and other files, such as images, to a static web site. It is thoroughly
customizable, and comes with a pre-configured web site skeleton that can help get
you started, and serve as an example of its use.

Linton is meant to be simple to use, simple to install and maintain, and its
code should be easy to understand; it is also designed to work for a long
time, with only a few carefully chosen dependencies outside the core Python
system.

Linton is free software, licensed under the GNU General Public License
version 3, or (at your option) any later version. See the file COPYING.

See https://rrthomas.github.io/linton for more information.
capella-ros-tools 0.1.dev74
Tools for importing ROS .msg files into Capella data package and vice versa.
Requires Python: <3.15,>=3.12

<!--
 ~ Copyright DB InfraGO AG and contributors
 ~ SPDX-License-Identifier: Apache-2.0
 -->

# Capella ROS Tools

![image](https://github.com/dbinfrago/capella-ros-tools/actions/workflows/build-test-publish.yml/badge.svg)

Tools for importing ROS .msg files into Capella `DataPackage`, `DataType` and
`Class` objects, or exporting those objects to .msg files.

![Showcase](https://i.imgur.com/hs4EUnL.gif)

# Documentation

Read the [full documentation on Github pages](https://dbinfrago.github.io/capella-ros-tools).

# Examples

Import local ROS .msg files to Capella model layer's root data package:

```sh
python -m capella_ros_tools \
import \
-i tests/data/data_model/example_msgs \
-m tests/data/empty_project_60 \
-l la \
--no-deps
```

Import remote ROS .msg files to Capella model layer's root data package:

```sh
python -m capella_ros_tools \
import \
-i git+https://github.com/DSD-DBS/dsd-ros-msg-definitions-oss \
-m tests/data/empty_project_60 \
-l la
```

Export local Capella model layer's root data package as ROS .msg files:

```sh
python -m capella_ros_tools \
export \
-m tests/data/melody_model_60 \
-l la \
-o tests/data/melody_msgs
```

Export remote Capella model layer's root data package as ROS .msg files:

```sh
python -m capella_ros_tools \
export \
-m git+https://github.com/DSD-DBS/coffee-machine \
-l sa \
-o tests/data/coffee_msgs
```

# Installation

You can install the latest released version directly from PyPI.

```sh
pip install capella-ros-tools
```

# Contributing

We'd love to see your bug reports and improvement suggestions! Please take a
look at our [guidelines for contributors](CONTRIBUTING.md) for details. It also
contains a short guide on how to set up a local development environment.

# Licenses

This project is compliant with the
[REUSE Specification Version 3.0](https://git.fsfe.org/reuse/docs/src/commit/d173a27231a36e1a2a3af07421f5e557ae0fec46/spec.md).

Copyright DB InfraGO AG, licensed under Apache 2.0 (see full text in
[LICENSES/Apache-2.0.txt](LICENSES/Apache-2.0.txt))

Dot-files are licensed under CC0-1.0 (see full text in
[LICENSES/CC0-1.0.txt](LICENSES/CC0-1.0.txt))
synapsefrc 2026.0.1
Dynamic vision processing system for FRC coprocessors
Requires Python: <=3.14,>=3.11

![](https://github.com/DanPeled/Synapse/blob/docs/docs/.gitbook/assets/SynapseHeader.png?raw=true)

[![PyPI Downloads](https://static.pepy.tech/badge/synapsefrc)](https://pepy.tech/projects/synapsefrc)

- **Pipeline System:** Organize and manage vision processing tasks efficiently.
- **Multiple Camera Support:** Handle multiple camera inputs simultaneously.
- **NetworkTables Integration:** Post vision results directly to NetworkTables for easy access in FRC dashboards.
- **Global Pipeline Configuration:** Easily configure global pipeline settings.
- **Fast Pipeline Development:** Streamlined workflow for creating and testing new pipelines.
- **Custom Python Pipelines:** Load and run custom Python-based vision pipelines.
- **Realtime Settings:** Adjust settings in real-time through NetworkTables & UI.
- **Dynamic Pipeline Creation:** Create and modify pipelines dynamically.
- **Interactive UI:** A responsive, visual interface for:
  - Viewing live camera feeds
  - Managing and switching between pipelines
  - Tuning pipeline parameters in real-time
  - Monitoring output data and debugging visually
    Designed for intuitive interaction and minimal setup.

[Documentation](https://danpeled.gitbook.io/synapse/)
[Discord Server](https://discord.gg/zHJRV8Stj3)

## Project Structure

- `synapse_core`: Contains the core Python library for Synapse.
- `synapse_net`: Contains the networking library for the runtime, including NetworkTables and socket communication, as well as Protocol Buffers message definitions.
- `synapse_lib` Contains the vendordep library for the robot to communicate with the Synapse runtime.
- `synapse_ui`: Contains the graphical user interface (UI) for interacting with the Synapse runtime.

## License

This project is licensed under the [GNU V3 License](LICENSE).
openenergyid 0.1.36
Open Source Python library for energy analytics and simulations
Requires Python: >=3.11
Keywords: energy, analytics, simulation

# OpenEnergyID

Open Source Python library for energy data analytics and simulations.

OpenEnergyID is a powerful Python library that provides a wide range of tools for energy data analysis and simulation. Whether you are a data scientist, researcher, or developer working in the energy sector, OpenEnergyID can help you gain valuable insights from your data and build sophisticated models.

[*more info for developers*](DEVELOPERS.md)

## Getting Started

To get started with OpenEnergyID, you can install it using `pip`:

```bash
pip install openenergyid
```

## Analyses

OpenEnergyID provides a variety of analysis modules to help you work with your energy data.

### Baseload Analysis

The baseload analysis module helps you determine the baseload consumption of a building or a portfolio of buildings.

- Use `BaseloadAnalyzer(timezone="Europe/Brussels")`, prepare data with `prepare_power_series(energy_lf)` and then call `analyze(power_lf, "1h")`.
- Accepts either energy (`timestamp`/`total` in kWh per 15 min) or precomputed power (`timestamp`/`power` watts); gapped or zero-valued intervals are kept and handled safely.
- For homes with unmeasured PV, use `nighttime_only=True` to filter to nighttime readings only (uses pvlib for solar position).
- Outputs energy splits (baseload vs total) and baseload ratios per chosen reporting granularity, keeping computations lazy via Polars `LazyFrame`.

### Capacity Analysis

The capacity analysis module helps you identify peaks in your power data.

```python
from openenergyid.capacity import CapacityAnalysis

analyzer = CapacityAnalysis(data=power_series, threshold=2.5)
peaks = analyzer.find_peaks()
```

### Dynamic Tariff Analysis

The dynamic tariff analysis module helps you analyze the impact of dynamic tariffs on your energy costs.

```python
from openenergyid.dyntar import calculate_dyntar_columns

df_with_dyntar = calculate_dyntar_columns(df)
```

### Energy Sharing

The energy sharing module helps you simulate energy sharing scenarios.

```python
from openenergyid.energysharing import calculate

result = calculate(df, method=CalculationMethod.OPTIMAL)
```

### Multivariate Linear Regression (MVLR)

The MVLR module helps you build multivariate linear regression models to predict energy consumption.

```python
from openenergyid.mvlr import find_best_mvlr

model = find_best_mvlr(data)
```

### PV Simulation

The PV simulation module helps you simulate the output of a photovoltaic system.

```python
from openenergyid.pvsim import get_simulator, apply_simulation

simulator = get_simulator(input)
simulation_results = simulator.simulate()
df_with_pv = apply_simulation(df, simulation_results)
```

### Simulation Evaluation

The simulation evaluation module helps you evaluate the results of your energy simulations.

```python
from openenergyid.simeval import evaluate

evaluation = evaluate(df)
```
cit-pydata 0.0.2.dev5
Python clients for commonly used api services including Salesforce, SQL, Marketo, Box, SFSync*, and JobLog*
Requires Python: >=3.12

# cit-pydata 

This repo provides Python clients for commonly used api services including Salesforce, SQL, Marketo, Box, SFSync*, and JobLog*.  

*SFSync = custom Salesforce <> MSQ SQL integration  
*JobLog = custom centralized logging for data integration jobs
t-ocr 1.5.6
Thoughtful OCR Package
Requires Python: >=3.8
Keywords: thoughtful-ocr, t-ocr, t_ocr

T-OCR Library
--------------

This is a Python library that contains methods for easy and fast OCR parsing with various tools. Used to read scanned PDF documents and images with text.

|

Key Features
------------

1. File parsing is done in the AWS cloud, eliminating the need for additional dependencies on your machine.
2. Parsing of each page is done in parallel in AWS, resulting in a significantly faster parsing process.
3. Access to the T-OCR AWS part is required to use the library.
4. Combines the best OCR tools and provides a consistent interface, making it easy to use and switch between tools.

    .. code-block:: python

         # Parsing with Tesseract (Free OCR)
         free_ocr = FreeOCR()
         pages = free_ocr.read_pdf("1.pdf")
         for page in pages:
             print(page.full_text)

    .. code-block:: python

         # Parsing with Textract
         textract = Textract()
         pages = textract.read_pdf("1.pdf")
         for page in pages:
             print(page.full_text)

5. The package contains a large number of powerful methods that will help you save time and read parsed data faster and better.

    .. code-block:: python

         # Get dates etc. from text
         date_matches = get_valid_dates("Text - February 17, 2009, text...")  # 02/17/2009

         # Compare the real text with what the OCR read
         does_strings_match_by_fuzzy("Apple", "Appla", percentage=0.8)  # True
         does_text_contains_string_by_fuzzy("Apple", "Appla watch", percentage=0.8) # True

         text = "Long article about Appla watch"
         find_string_in_text_by_fuzzy("Apple", text, percentage=0.8)  # 19

6. Caching OCR results locally in `t_ocr_cache` folder is supported. Use this during development to avoid blocking parsing time.

    .. code-block:: python

         pdf_file = "file.pdf"
         # First run
         free_ocr.read_pdf("1.pdf", cache_data=True) # Takes 15 seconds
         # Every next run
         free_ocr.read_pdf("1.pdf", cache_data=True) # Takes 0.01 seconds

         # If the state of the file or arguments changes, it will save the cache for this call too
         free_ocr.read_pdf("1.pdf", dpi=500, cache_data=True) # Takes 15 seconds
         free_ocr.read_pdf("1.pdf", dpi=500, cache_data=True) # Takes 0.01 seconds

|

Supported OCR Tools
-------------------

**1. Tesseract (Free OCR)**

    - 🆓 Free
    - ✅ Read text
    - ❌ Read tables, vertical field values
    - ⬛ Simple form design preferred

**2. AWS Textract**

    - 💸 Paid
    - ✅ Read text
    - ✅ Read tables, vertical field values
    - 🌃 Flexible for different file designs
apb-extra-utils 1.0.3
Miscellaneous utils for python
Requires Python: >=3.6

##### Package <em>apb_extra_utils</em>

Modules used on different commonly cases founded in typical projects dealing with strings, mails, 
logging, sql, xml, excel, postgres, Github api and others.

To install:
```shell
pip install apb_extra_utils
```

Documentation here [apb_extra_utils](https://serveis.portdebarcelona.cat/generic_python_packages/apb_extra_utils.html)