semvec/pypi-packages huggingface dataset:
little-llama 0.0.2
Get information from custom text

## LLAMA

This is an openai model that able you to give your own text to it and ask question of that text from model.

To use this model first you need to buy a token from openai.

link of model documentation:

https://docs.llamaindex.ai/


## How to use Model:

```
lama = llama_model("Your data text file directory, "Your open ai token)
result = lama.getquery("Your query)
print(result)
```
huffman-algorithm 1.0.1
Python Huffman Algorithm Implementation
Requires Python: >=3.12

# huffman-algorithm
<div align="center">
    Huffman algorithm is a python implementation of the <b>huffman algorithm</b> it's an efficient encoding algorithm for text.
    <br>
    <br>
    <img alt="GitHub License" src="https://img.shields.io/github/license/ugo-brocard/huffman-algorithm"/>
    <img alt="GitHub Workflow Status (with event)" src="https://img.shields.io/github/actions/workflow/status/ugo-brocard/huffman-algorithm/publish.yml"/>
    <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/huffman-algorithm"/>
    <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/ugo-brocard/huffman-algorithm"/>
</div>

## ✨ Key features
- [x] Count letters
- [x] Tree generation
- [x] Dictionary generation
- [x] Letter frequency calculation
- [x] String encoding
- [x] String decoding
  
- [ ] Tree visualisation

It works with python 3.12 or later

***

## 🔧 Installation

It should work on any python3 version after the 1.10 but it's always good to have the latest version since it will be the one I'm sure it works on :)

### ⚙ Using PyPi

``` bash
$ pip install huffman-algorithm
```

## 📚 Usage

### 📕 Dictionary generation
```py
from huffman import Huffman

dictionary = Huffman.generate_dictionary("Hello World")

# How to see the dictionary ?
print(dictionary)    # Output: {'W': '000', 'd': '001', 'e': '010', 'r': '011', 'l': '10', 'o': '110', ' ': '1110', 'H': '1111'}
```

### 🌳 Tree generation
```py
from huffman import Huffman

tree = Huffman.generate_tree("Hello World")

# How to see the tree ?
print(tree)    # Output: Node(character=None, frequency=11, children=[Node(character=None, frequency=4, children=[...]])
```

### 🔢 Letter frequency calculation
```py
from huffman import Huffman

frequencies = Huffman.get_letters_frequency("Hello World")

# How to see the encoded string ?
print(frequencies)    # Output: {' ': 1, 'H': 1, 'W': 1, 'd': 1, 'e': 1, 'r': 1, 'o': 2, 'l': 3}
```

### ⚙️ String encoding
```py
from huffman import Huffman

encoded = Huffman.encode("Hello World")

# How to see the encoded string ?
print(encoded)    # Output: '11110101010110111000011001110001'
```

### ⚙️ String decoding
```py
from huffman import Huffman

encoded = Huffman.encode("Hello World")
dictionary = Huffman.generate_dictionary("Hello World")

decoded = Huffman.decode(encoded, dictionary)

# How to see the decoded string ?
print(decoded)    # Output: 'Hello World'
```

## 🍕 Contributing
All contribution are welcomed so consider looking at the source code on [GitHub](https://github.com/ugo-brocard/huffman-algorithm)

## 🛡 License

This project is licensed under the [MIT License](https://github.com/ugo-brocard/huffman-algorithm/blob/main/LICENSE)
sparse-framework 1.2.0
Stream Processing Architecture for Resource Subtle Environments
Requires Python: >=3.7

# Sparse

This repository contains source code for Stream Processing Architecture for Resource Subtle Environments (or just
Sparse for short). Additionally, sample applications utilizing Sparse for deep learning can be found in examples
directory.

```
pip install sparse-framework
```

## Example Applications

The repository includes example applications (in the [examples directory](https://github.com/AnteronGitHub/sparse/blob/master/examples)). The applications are tested
tested with the following devices and the following software:

| Device            | JetPack version | Python version | PyTorch version | Docker version | Base image                                     | Docker tag suffix |
| ----------------- | --------------- | -------------- | --------------- | -------------- | ---------------------------------------------- | ------------------ |
| Jetson AGX Xavier | 5.0 preview     | 3.8.10         | 1.12.0a0        | 20.10.12       | nvcr.io/nvidia/l4t-pytorch:r34.1.0-pth1.12-py3 | jp50               |
| Lenovo ThinkPad   | -               | 3.8.12         | 1.11.0          | 20.10.15       | pytorch/pytorch:1.11.0-cuda11.3-cudnn8-runtime | amd64              |

[Follow these instructions to run the example applications with Kubernetes](https://github.com/AnteronGitHub/sparse/blob/master/k8s).

# Publishing to PyPi

Follow the instructions below to update PyPi index after a new version has been released.

1. Update version number in `pyproject.toml`
1. Update PyPA's `build` package by running:
```
python3 -m pip install --upgrade build
```
1. Build project package by running:
```
python3 -m build
```
1. Update PyPA's `twine` package by running:
```
python3 -m pip install --upgrade twine
```
1. Upload the built package by running:
```
python3 -m twine upload dist/*
```

# Citation in articles

The following article introduces this design (corresponds to version `v1.0.0-rc2`):
```
@INPROCEEDINGS{10403079,
  author={Vainio, Antero and Mudvari, Akrit and Kiedanski, Diego and Tarkoma, Sasu and Tassiulas, Leandros},
  booktitle={2023 IEEE 7th International Conference on Fog and Edge Computing (ICFEC)},
  title={Fog Computing for Deep Learning with Pipelines},
  year={2023},
  volume={},
  number={},
  pages={64-72},
  keywords={Training;Program processors;Computational modeling;Pipelines;Hardware;Task analysis;Edge computing;fog computing;stream processing systems;deep learning},
  doi={10.1109/ICFEC57925.2023.00017}}
```
omsdetector-forked 2024.1.31
Forked omsdetector to make it compliant with current python versions and dependencies
Requires Python: >=3.9,<4.0

# A Python program to analyze collections of Metal Organic Frameworks (MOFs) for open metal sites.
Author: Emmanuel Haldoupis <emmhald@gmail.com>

March 12th 2018

## Description

Given a set of CIF files this program can read the files, analyze the structures and
detect all the unique open metal sites present in each structure.

The first step is to create a collection containing all the desired CIF files. We can do
this by pointing to a folder containing the CIF files.

```
from omsdetector-forked import MofCollection
mof_coll = MofCollection.from_folder(collection_folder="path to cif folder",
                                     analysis_folder="path to analysis folder")
```

Where **collection_folder** is the folder where the CIF files are located and **analysis_folder** is the folder where the results will be saved.


The analysis is run using the following command on the mof_coll object:

```
mof_coll.analyse_mofs()
```

Specifying a value for num_batches instructs the analysis to run in parallel in the specified number
of batches, each as a separate process.

Once the results have finished they can be summarized using the following methods:

```
mof_coll.summarize_results()
mof_coll.summarize_tfactors()
```

The summarize_results() method generates a table that summarizes the number of open metal sites found for each metal type.
The summarize_tfactors() method generates histograms (and stores them) for the distribution of the t-factors, which indicate
the degree of deviation from a closed coordination sphere for tetra, penta, and hexa-coordinated coordination spheres.

Finaly, a collection can be filtered to create a sub-collection using the following filters:

* "density": [min, max] (range of values)
* "oms_density": [min, max] (range of values)
* "uc_volume":  [min, max] (range of values)
* "metal_species": ["Cu", "Zn", ...] (list of metal species)
* "non_metal_species": ["C", "N", ...] (list of non metal species)
* "cif_okay": True (boolean value)
* "has_oms": True (boolean value)
* "mof_name":  [mof_name1, mof_name2] (string values)

For example:

```
co_oms = mof_coll.filter_collection(using_filter={"metal_species":["Co"], "has_oms":True})
```
See the example jupyter notebook for more details.

## Requirments
* python >=3.9
* pymatgen >=2023.2.28
* pandas 1.3.5
* numpy 1.21.6
* matplotlib 2.1.1

## Reference

Chung, Yongchul; Haldoupis, Emmanuel; Bucior, Benjamin; Haranczyk, Maciej ; Zhang, Hongda; Vogiatzis, Konstantinos; Milisavljevic, Marija; Ling, Sanliang; Camp, Jeffrey; Slater, Ben; Siepmann, J.; Sholl, David; Snurr, Randall *Computation-Ready, Experimental Metal-Organic Framework Database 2018: Additional Structures, Open Metal Sites, and Crystal Reconstruction* (submited to Chemistry of Materials)
smaller-llama 0.0.1
Get information from custom text

## LLAMA

This is an openai model that able you to give your own text to it and ask question of that text from model.

To use this model first you need to buy a token from openai.

link of model documentation:

https://docs.llamaindex.ai/


## How to use Model:

```
lama = llama_model("Your data text file directory, "Your open ai token)
result = lama.getquery("Your query)
print(result)
```
gnnuers 0.0.6.3
A library to generate explanations of recommendations generated by GNNs.

GNNUERS generates explanations in the form of user-item interactions that make
a GNN-based recommender system favor a demographic group over another. GNNUERS learns a perturbation
vector that modifies the adjacency matrix representing the training network. The edges modified by
the perturbation vector are the explanations genereated by the framework. GNNUERS then needs to work on a slight
extended version of a recommender system in order to include the perturbation vector and optimize it.