semvec/pypi-packages huggingface dataset:
niftyfetcher 0.1.3
📈 A CLI tool to fetch historical OHLC data for stocks using Upstox API
License: MIT
Requires Python: >=3.8
Keywords: cli, data, historical, market, nifty, stock, trading, upstox

# 📈 NiftyFetcher

A powerful CLI tool to fetch historical OHLC (Open, High, Low, Close) data for stocks using the Upstox API.

## 🚀 Features

- Fetch historical stock data with customizable time intervals
- Support for multiple time units (minute, hour, day, week, month)
- Export data to CSV or Excel formats
- Automatic handling of large date ranges with intelligent chunking
- Clean, user-friendly command-line interface
- Error handling with detailed feedback

## 📦 Installation

Install from PyPI:

```bash
pip install niftyfetcher
```

Or install from source:

```bash
git clone https://github.com/yash2002vardhan/niftyfetcher.git
cd niftyfetcher
pip install -e .
```

## 🛠️ Usage

### Basic Syntax

```bash
niftyfetcher INSTRUMENT_KEY UNIT INTERVAL FROM_DATE TO_DATE FILE_TYPE
```

### Arguments

| Argument | Description | Example Values |
|----------|-------------|----------------|
| `INSTRUMENT_KEY` | Upstox instrument key for the stock | `NSE_EQ\|INE002A01018` |
| `UNIT` | Time unit for data | `minutes`, `hours`, `days`, `weeks`, `months` |
| `INTERVAL` | Interval within the unit | `1`, `5`, `15`, `30` |
| `FROM_DATE` | Start date (YYYY-MM-DD) | `2024-01-01` |
| `TO_DATE` | End date (YYYY-MM-DD) | `2024-01-31` |
| `FILE_TYPE` | Output format | `csv` or `xlsx` |

### 📋 Examples

**Fetch daily data for Nifty 50:**
```bash
niftyfetcher "NSE_INDEX|Nifty 50" days 1 2024-01-01 2024-01-31 csv
```

**Fetch 5-minute interval data:**
```bash
niftyfetcher "NSE_EQ|INE002A01018" minutes 5 2024-01-15 2024-01-16 xlsx
```

**Fetch weekly data for a year:**
```bash
niftyfetcher "NSE_EQ|INE002A01018" weeks 1 2023-01-01 2023-12-31 csv
```

### 📊 Output

The tool generates files with the following naming convention:
```
{instrument_key}_{unit}_{interval}_{from_date}_{to_date}.{file_type}
```

Output contains columns:
- `timestamp` - Date/time of the data point
- `open` - Opening price
- `high` - Highest price
- `low` - Lowest price
- `close` - Closing price

## 🔧 Getting Help

```bash
niftyfetcher --help
```

## 📝 Requirements

- Python 3.8+
- Internet connection for API access

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## ⚠️ Disclaimer

This tool is for educational and research purposes. Always verify data accuracy for trading decisions. The authors are not responsible for any financial losses.

## 🐛 Issues

If you encounter any issues, please report them on [GitHub Issues](https://github.com/yash2002vardhan/niftyfetcher/issues).

## ⚠️ Note on Rate Limits

Please be mindful of the rate limits imposed by the Upstox API to avoid errors or temporary bans. While this tool includes basic safeguards (such as delays between requests), it is ultimately your responsibility to ensure you do not exceed Upstox's allowed request limits. The authors are not liable for any issues arising from rate limit violations.
mimicx 0.1.86
Human-like AI for everyone — vision, text, voice, and more in one simple package.
License: MIT
Requires Python: >=3.9

# MIMICX AI Library 📚

[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![PyPI version](https://img.shields.io/pypi/v/genai-processors.svg)](https://pypi.org/project/mimicx/)

**Create Human-Like AI: Perception, Reasoning, and Interaction in One Library**

Mimicx AI is a lightweight Python library for giving machines human-level perception and decision-making capabilities by enabling advanced perception, contextual reasoning, autonomous decision-making, and intuitive human-machine interaction.

At its core, Mimicx structures its capabilities into specialized domains — `Vision`, `Text`, `Voice`, `Feel`, `Twin`, `Phy`, `Sense`, and `Mind` — each targeting a unique dimension of machine perception, reasoning, and interaction.

## Sample: Face Recognition 

```python
from mimicx import Model

# Initialize load model
model = Model("mimicvision/face_recognition")

# Compare faces
result = model.compare_faces(image1_path, image2_path)
print(f"Face similarity: {result:.2f}")
       
```



## Sample: Iris Recognition 

```python
from mimicx import Model

# Initialize load model
model = Model("mimicvision/iris_recognition")

# Compare faces
result = model.compare_iris(image1_path, image2_path)
print(f"Iris similarity: {result}")

```


## Notes
* Ensure that the images exist in the same directory as this script.

* The MimicX package must be installed and properly configured.

* The load('face_recognition') call initializes the face recognition model.



## ✨ Key Features

*   **MimicVision**:  processes and interprets visual data, enabling advanced image and video understanding.

*   **MimicText**: handles natural language processing and contextual text reasoning.

*   **MimicVoice**: works with audio signals for speech recognition, synthesis, and voice interaction.

*   **MimicFeel**: captures and interprets tactile and sensory data to simulate touch and emotion.

*   **MimicTwin**: creates and manages digital twins, bridging physical and virtual environments.

*   **MimicPhy**: interfaces with physical systems for autonomous control and robotics.

*   **MimicSense**: integrates multisensory data streams for comprehensive environmental awareness.

*   **MimicMind**: enables high-level cognitive functions including planning, decision-making, and adaptive learning.


## 📦 Installation

The GenAI Processors library requires Python 3.10+.

Install it with:

```bash
pip install mimicx
```


## 🤝 Contributing

Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for
guidelines on how to contribute to this project.

## 📜 License

This project is licensed under the MIT License, See the
[LICENSE](LICENSE) file for details.

## Mimicx Terms of Services

If you make use of Mimicx via the MimicX library, please ensure you
review the [Terms of Service](https://mimicx.ai).
curie 0.0.33
Curie is a python toolkit to aid in the analysis of experimental nuclear data.
License: MIT

# Curie

Curie is a python toolkit to aid in the analysis of experimental nuclear data.  Its name is inspired by Marie Curie, who developed the theory of radioactivity.

The primary application for Curie is (gamma-ray) activation analysis, with specific utilities developed for the charged-particle stacked-target activation technique.
Curie also comes with access to a number of nuclear structure, and nuclear reactions databases.  It also has methods for accessing atomic properties,
such as attenuation coefficients and charged particle stopping powers.

## Features

Curie's features are primarily class based.  Here are a few examples:

* Spectrum - Peak fitting for HPGe detector data
* Calibration - Energy & efficiency calibration tool (for HPGe detectors)
* Stack - Stacked-target energy loss characterization
* DecayChain - General purpose Bateman equation solver
* Isotope - Isotopic mass and decay data
* Reaction - Cross sections from multiple libraries
* Library - Tool for searching and retrieving cross sections from multiple libraries

More detail can be found in the [User's Guide](https://jtmorrell.github.io/curie/build/html/usersguide/index.html) and the [API](https://jtmorrell.github.io/curie/build/html/api/index.html).

## Quick Install

Curie is available through the [Python Package index](https://pypi.org/), which allows installation using Python's standard command line utility [pip](https://pip.pypa.io/en/stable).  Assuming Python and Pip are installed already, you can install Curie with the command:

```
pip install --user curie
```

or:

```
python -m pip install --user curie
```

Detailed installation instructions and troubleshooting can be found in the Curie [documentation](https://jtmorrell.github.io/curie/build/html/quickinstall.html).
NetDes 1.0.6
Network modeling based on dynamic equation simulation (NetDes)
License: MIT
Requires Python: >=3.9
Keywords: NetDes, TF, ODE, GRN, trajectories

# NetDes

#### <ins>Net</ins>work inference and optimization using <ins>D</ins>ynamical <ins>e</ins>quation <ins>s</ins>imulations

NetDes is a computational method for optimizing gene regulatory networks (GRNs) of core transcription factor (TF) based on gene expression time trajectories. NetDes was specifically designed for analyzing time-series scRNA-seq data. The NetDes pipeline contains the following steps. 

* (1) NetDes calculates smoothed gene expression trajectories along inferred pseudotime.

* (2) Genes are then clustered according to the trajectories.

* (3) Core TFs are inferred for each gene cluster using gene set analysis and TF-target gene relationship. 

* (4) An initial GRN of core TFs is constructed according to TF-target gene relationship, where target genes also belong to the core TFs.

* (5) Network optimization that refines the GRN and constructs a dynamical model using ordinary differential equations (ODEs).

* (6) Dynamical systems modeling, such as gene perturbation simulations, signal driving simulations, network coarse-graining.

## Installation
Python version 3.9 or greater is required.

#### Install from PyPi (recommended)
To install the most recent release, run

`pip install NetDes`

#### Install with github
* Git clone the [NetDes repository](https://github.com/lusystemsbio/NetDes), cd to the `NetDes` directory, and run

`pip install .`

## Tutorials

[Processing gene expression time trajectories using scRNA-seq data]: This script illustrates the steps to process input scRNA-seq data, obtain smoothed gene expression time trajectories, and cluster genes based on the trajectories. (Steps 1 and 2)

[Inferring core TFs]: This script shows the inference of core transcription factors using Fisher's exact test. (Step 3)

[Initial GRN construction]: This script illustrates how to build an initial GRN using TF-target gene databases like Rcistarge, TRRUST, and NetAct. (Step 4)

[GRN optimization and simulation]: This tutorial page shows the NetDes' usage for network optimization and simulation. The user input includes pseudotime, smoothed gene expression trajectories, and an initial GRN.

[Benchmarking]: This script explains the steps for GRN evaluation by comparing RACIPE simulations with the scRNA-seq data. (Step 5)

[Network coarse-graining]: This script shows the process of coarse-graining the optimized GRN into a small gene circuit using [SacroGraci](https://github.com/lusystemsbio/SacoGraci). (Step 6)
cadmium-fastapi-sdk 1.0.0
Cadmium SDK for capturing and sending FastAPI errors
License: MIT
Requires Python: >=3.8
Keywords: fastapi, error-tracking, monitoring, cadmium

# Cadmium-FastAPI SDK

This SDK captures and sends errors from your FastAPI application to the Cadmium server.

## Installation

```bash
pip install cadmium-fastapi-sdk
```

## Configuration

Add the following to your FastAPI application:

```python
from fastapi import FastAPI
from cadmium_fastapi import CadmiumMiddleware

app = FastAPI()

# Add Cadmium middleware
app.add_middleware(
    CadmiumMiddleware,
    application_id="your-application-id",
    cd_secret="your-secret",
    cd_id="your-cd-id"
)
```

## Environment Variables (Alternative Configuration)

You can also configure using environment variables:

```bash
export CADMIUM_APPLICATION_ID="your-application-id"
export CADMIUM_CD_SECRET="your-secret"
export CADMIUM_CD_ID="your-cd-id"
```

Then simply add the middleware without parameters:

```python
from cadmium_fastapi import CadmiumMiddleware

app.add_middleware(CadmiumMiddleware)
```

## Usage

Once configured, any unhandled exception will automatically be sent to the Cadmium server.

## Manual Error Reporting

You can also manually report errors:

```python
from cadmium_fastapi import report_error

try:
    # Your code here
    pass
except Exception as e:
    await report_error(e, request)
```
humblydb 0.9.0
A module for noob Programmers
License: MIT
Requires Python: >=3.6

# Simple Data Storage Library (SQLite + Pickle)

This Python library provides an easy way to store and retrieve key-value data using SQLite and `pickle`. It also includes a basic Tkinter GUI that explains how to use the library.

## Features

- Store any Python object with a key
- Uses SQLite as backend with a single-row table
- Serialized using `pickle`
- Simple and unified `save_data()` function
- GUI helper included to show usage instructions

## Installation

No installation required. Just copy the Python files into your project. Make sure to have:

```bash
Python 3.x
```

## Usage

```python
from your_module import save_data, see_data

# Save data
save_data(db_name="mydb", data="1234", data_name="password")

# Retrieve data
print(see_data(db_name="mydb", data_name="password"))
```

- `db_name`: name of the SQLite file (without `.db`)
- `data_name`: the key to store the value under
- `data`: any serializable Python object

## GUI Helper

Run `tkinter_gui_helper.py` to view usage instructions in a simple graphical window.

## License

MIT License