semvec/pypi-packages huggingface dataset:
irdf 1.4
Jupyter extension for interacting with RDF graphs
Requires Python: >=3.8
Keywords: ipython, jupyter, visualization, interaction, interact

# irdf: Interactive RDF graph widgets in Jupyter
This package allows you to visualize your RDFlib graph objects in two ways: as triple tables or a network visualization.

In the triple tables, you can filter the triples by subject, predicate or object value.

In the network visualizations, you can see the relations between entities, and the literals associated with them.

## Install
```
pip install irdf
```

## Usage
```python
import rdflib
import irdf

# Create a Graph
g = rdflib.Graph()

# Parse in an RDF file hosted on the Internet
g.parse('http://dbpedia.org/data/Vrije_Universiteit_Amsterdam.ttl')
```

```python
# Get an interactive table
irdf.table(g)
```
![table](https://raw.githubusercontent.com/bennokr/irdf/main/preview-table.png)

```python
# Get an interactive graph (filtering on certain properties)
# Click on nodes to see associated literals!
irdf.graph(g, p_filter=['/ontology/', 'depiction'], lang='en')
```
![graph](https://raw.githubusercontent.com/bennokr/irdf/main/preview-graph.png)

### Wikidata
In Wikidata, the labels of properties are associated with special property entities.
To get nice labels on edges in your visualization, you can specify a custom SPARQL property path to fetch them:

```python
import rdflib, irdf
g = rdflib.Graph()
g.parse('https://www.wikidata.org/wiki/Special:EntityData/Q1065414.ttl')
label_path = '(^wikibase:directClaim)*/rdfs:label'
irdf.graph(g, p_filter=['/direct/'], lang='en', label_path=label_path)
```

## Acknowledgements
This library is based on the great work of [ipycytoscape](https://github.com/cytoscape/ipycytoscape) and [itables](https://github.com/mwouts/itables).
table-trimmer 0.1.0
Uma ferramenta utilitária para otimizar bancos de dados SQLite ao permitir que os usuários selecionem e mantenham apenas as colunas essenciais em novas tabelas derivadas. Isso ajuda na criação de tabelas mais enxutas, melhorando a gestão e o desempenho do banco de dados ao reduzir a quantidade de dados desnecessários. Ideal para limpeza de dados, análises específicas e para otimizar o armazenamento e a consulta em bancos de dados grandes.
Requires Python: >=3.6


# Table Trimmer

`table-trimmer` Ã© uma ferramenta desenvolvida para otimizar bancos de dados SQLite. Este pacote permite aos usuÃ¡rios criar tabelas mais enxutas, selecionando e mantendo apenas as colunas essenciais. Isso melhora a eficiÃªncia do banco de dados ao reduzir o volume de dados desnecessÃ¡rios.

## InstalaÃ§Ã£o

VocÃª pode instalar o `table-trimmer` utilizando pip:

```bash
pip install table-trimmer
```

## Uso

Para usar o `table-trimmer`, execute o seguinte comando no terminal:

```bash
table-trimmer
```

Siga as instruÃ§Ãµes interativas para selecionar o arquivo do banco de dados e a tabela que deseja otimizar. VocÃª serÃ¡ capaz de escolher as colunas que deseja manter na nova tabela enxuta.


## LicenÃ§a

Este projeto estÃ¡ licenciado sob a LicenÃ§a MIT - veja o arquivo LICENSE para detalhes.
bandsplit-tensorflow 0.1.2
A non-official implementation of the BandSplit technique as a TensorFlow layer.
Requires Python: >=3.6

# Non-official BandSplit implementation as a TF 2.0 layer 

Implementation of the BandSplit technique used in ["Music Source Separation with Band-split RNN"](https://arxiv.org/abs/2209.15174).

## Installlation
```bash
pip install bandsplit_tensorflow
```
## Usage
```python
import tensorflow as tf 
from bandsplit_tensorflow import BandSplitLayer

# Input parameters
input_time_dim = 100
input_freq_dim = 257
batch_size = 100
sr = 16000
# Hyperparameters
sub_band_feature_dim = 128

# Define layer
band_split_layer = BandSplitLayer(input_freq_dim=input_freq_dim, sr=sr, sub_band_feature_dim=sub_band_feature_dim)

# Use layer
random_spectrogram = tf.random.normal((batch_size, input_time_dim, input_freq_dim))
result = band_split_layer(random_spectrogram)
print(result)
```

## Notes:
* The implementation is only designed for a sample rate of 16 kHz
text2topicloss 1.0.0
Text2topic loss for bi-encoder models
Keywords: text2topic, nlp, topic modeling, BERT, BERTopic

# Text2Topic

Implementation of bi-encoder Text2Topic architecture describe in *Text2Topic: Multi-Label Text Classification System for Efficient Topic Detection in User Generated Content with Zero-Shot Capabilities*

**Read the paper & the original repository for details about the algorithm !**

- PAPER : https://aclanthology.org/2023.emnlp-industry.10/

![Text2topic schema](https://raw.githubusercontent.com/azaismarc/text2topic/master/text2topic.png)

## Installation

```bash
pip install text2topicloss
```

or

```bash
git clone
python -m pip install .
```
## Citations

**I'm not the author of the original paper**, so if you use this library, please cite the original paper :

```bibtex
@inproceedings{wang-etal-2023-text2topic,
    title = "{T}ext2{T}opic: Multi-Label Text Classification System for Efficient Topic Detection in User Generated Content with Zero-Shot Capabilities",
    author = "Wang, Fengjun  and
      Beladev, Moran  and
      Kleinfeld, Ofri  and
      Frayerman, Elina  and
      Shachar, Tal  and
      Fainman, Eran  and
      Lastmann Assaraf, Karen  and
      Mizrachi, Sarai  and
      Wang, Benjamin",
    editor = "Wang, Mingxuan  and
      Zitouni, Imed",
    booktitle = "Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing: Industry Track",
    month = dec,
    year = "2023",
    address = "Singapore",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2023.emnlp-industry.10",
    doi = "10.18653/v1/2023.emnlp-industry.10",
    pages = "93--103",
}
```

## License

GNU General Public License v3.0
geokde 0.1.2
Package for geospatial kernel density estimation (KDE).
Requires Python: <4.0,>=3.10

![pypi version](https://img.shields.io/pypi/v/geokde)
![pypi downloads](https://img.shields.io/pypi/dm/geokde)
[![publish](https://github.com/duncanmartyn/geokde/actions/workflows/publish.yaml/badge.svg?branch=main)](https://github.com/duncanmartyn/geokde/actions/workflows/publish.yaml)
[![test](https://github.com/duncanmartyn/geokde/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/duncanmartyn/geokde/actions/workflows/test.yaml)
[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)

# GeoKDE
Package for geospatial kernel density estimation (KDE).

Written in Python 3.10.11 (though compatible with 3.10.11+), GeoKDE depends on the following:
- `geopandas`
- `numpy` (itself a dependency of `geopandas`)

# Examples
Perform KDE on a GeoJSON of point geometries and write the result to a GeoTIFF raster file with `rasterio`:
```
gdf = geopandas.read_file("vector_points.geojson")
kde_array, array_bounds = geokde.kde(gdf, 1, 0.1)
transform = rasterio.transform.from_bounds(
    *array_bounds,
    kde_array.shape[1],
    kde_array.shape[0],
)

with rasterio.open(
    fp="raster.tif",
    mode="w",
    driver="GTiff",
    width=kde_array.shape[1],
    height=kde_array.shape[0],
    count=1,
    crs=gdf.crs,
    transform=transform,
    dtype=kde_array.dtype,
    nodata=0.0,
) as dst:
    dst.write(kde_array, 1)
```

# Roadmap
- Add more kernels.
- Finish tests - coverage is >=95% for _utils.py and geokde.py as is.
- Implement other methods of distance measurement, e.g. haversine, Manhattan.
- Investigate alternatives to iterating over points.
- Enable use of single radius and weight values without filling array of the same length as the points GeoDataFrame/GeoSeries. Results in marginal speed up but the current approach may become an issue with very large point datasets.
- Integrate mypy in pre-commit, possibly also linter and formatter though flake8 and black used locally.

# Contributions
Feel free to raise any issues, especially bugs and feature requests!
pybindingcurve 1.2.3
Protein ligand binding simulation in Python
Requires Python: >=3.9
Keywords: molecular similarity, ligand based virtual screening

# PyBindingCurve

*Shave, Steven, et al. "PyBindingCurve, simulation, and curve fitting to complex binding systems at equilibrium." Journal of Chemical Information and Modeling (2021).* https://doi.org/10.1021/acs.jcim.1c00216

PyBindingCurve is a Python package for simulation, plotting and fitting of experimental parameters to protein-ligand binding systems at equilibrium.  In simple terms, the most basic functionality allows simulation of a two species binding to each other as a function of their concentrations and the dissociation constant (K<sub>D</sub>) between the two species.  A number of systems are built in and can be solved using direct analytical, kinetic, or Langrange multiplier based techniques.  User-defined custom systems can also be specified using a simple syntax.

Try without installing on Google colab! https://colab.research.google.com/drive/1upxm56mGYWo8jvTTJjZLOEq6DT0lRy8d


![PyBindingCurve simulation](https://raw.githubusercontent.com/stevenshave/pybindingcurve/master/pybindingcurve_logo.png "Breaking a dimer")

# Installation
PyBindingCurve may be installed from source present in the GitHub repository https://github.com/stevenshave/pybindingcurve via git pull, or from the Python Package Index (https://pypi.org/project/pybindingcurve/) using the command :
> pip install pybindingcurve

# Requirements
PyBindingCurve requires Python 3.9 or later. The following packages are also required
- numpy>=1.26
- matplotlib>=3.8
- lmfit>=1.2.2
- mpmath>=1.3.0
- autograd>=1.6.2

# License
[MIT License](https://github.com/stevenshave/pybindingcurve/blob/master/LICENSE)



# Usage
A tutorial and API documentation can be found [here](https://stevenshave.github.io/pybindingcurve/)

A quickstart example for simulation of protein-ligand binding is as follows:

```
import numpy as np
import pybindingcurve as pbc
my_system = pbc.BindingCurve("1:1")
system_parameters = {"p": np.linspace(0, 20), "l": 10, "kdpl": 1}
my_system.add_curve(system_parameters)
my_system.show_plot()
```
Tests written using the pytest framework may be run with 'pytest' (ensure pytest is installed in your python environment, or pip install it)

# Authors
PyBindingCurve was written by Steven Shave 
![email](https://raw.githubusercontent.com/stevenshave/pybindingcurve/master/email-address-image.gif)


Please get in contact for custom solutions, integration to existing workflows and training.