semvec/pypi-packages huggingface dataset:
scoped-mapping 0.9.1
Use orthogonal data to determine what ontologies should be used for mapping strings
License: MIT

scoped-mapping
==============

When mapping input strings from column/field ``X`` in some datasource to terms from OBO foundry ontologies, use the values in column/field ``Y`` to determine which ontology to map to.

Note that GitHub uses a hyphen and PyPI uses an underscore

Currently tested on a 32GB MacBook Pro running Catalina. Requires the riot library from Apache Jena. ``make all`` uses homebrew for installing Jena, but does not install homebrew. This will probably run on other 'nix systems but will require a system dependent installation of Jena.



Installation
------------
::

  python3.9 -m venv sm_venv
  source sm_venv/bin/activate
  pip install -r requirements.txt
  pip install -i https://test.pypi.org/simple/ scoped-mapping
  


Sample code
-----------

See Jupyter Notebooks

  


Scoping mappings based on subsets of NCBItaxon
----------------------------------------------

First download `semantic-sql` and some of its dependencies. Build an SQLite database with the NCBItaxon content. Building requires lots of disk space, RAM and patience. Well worth it when it comes to query time::

    make all

If a dataset has taxon values, one can use them to subset or scope how other values in the dataset should be mapped. For example, the NCBI Biosample metadata collection has MIxS triads (broad, narrow and medium) that could me mapped to ENVO terms in many cases. But ENVO might not be appropriate for cultured samples or samples that were taken from a multicellular organism. One way to check for those cases is looking for transitive subclasses in NCBItaxon. There are numerous ways to do that, but they are all generally computationally expensive.

Here, we use rdftab and relation-graph (via semantic-sql) to infer those transitive subClassOf relationships and load them into an SQLite database. Building this database requires lots of RAM and roughly 10 GB of disk space, but after that the querying is fast and convenient.

Building
---------

Once::

  pip install build twine

Every time::

  git add ...
  git commit -m ...
  git push 
  git tag ...
  pip install --use-feature=in-tree-build .
  
Ready to deploy?::

  python -m build --sdist --wheel .
  ls -l dist/
  
remove all artifacts from all builds in ``dist/`` except for the latest

::

  twine upload --repository pypitest dist/*
graphmlp-flax 0.0.1
Minimal Flax Implementation of Graph-MLP: Node Classification without Message Passing in Graph
License: MIT

# Minimal Flax Implementation of GraphMLP

In the past few months there have been various papers proposing MLP based architectures without Attention or Convolutions In this [paper](https://arxiv.org/abs/2106.04051), titled 'Graph-MLP: Node Classification without Message Passing in Graph', the authors introduce a new architecture for Node Classification.

## Installation

You can install this package from PyPI:

```sh
pip install graphmlp-flax
```

Or directly from GitHub:

```sh
pip install --upgrade git+https://github.com/SauravMaheshkar/GraphMLP-Flax.git
```

## Usage

```python
import jax.numpy as jnp
from graphmlp_flax.models import GMLP

net = GMLP(feature_dim=128, hidden_dim=128, num_classes=10, dtype=jnp.float32)
```

## Development

### 1. Conda Approach

```sh
conda env create --name <env-name> sauravmaheshkar/graphmlp
conda activate <env-name>
```

### 2. Docker Approach

```sh
docker pull ghcr.io/sauravmaheshkar/graphmlp-dev:latest
docker run -it -d --name <container_name> ghcr.io/sauravmaheshkar/graphmlp-dev
```

Use the [Remote Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) Extension in VSCode and [attach to the running container](https://code.visualstudio.com/docs/remote/attach-container). The code resides in the `code/` dir.

Alternatively you can also download the image from [Docker Hub](https://hub.docker.com/r/sauravmaheshkar/graphmlp-dev).

```sh
docker pull sauravmaheshkar/graphmlp-dev
```

## Citations

```bibtex
@misc{hu2021graphmlp,
      title={Graph-MLP: Node Classification without Message Passing in Graph},
      author={Yang Hu and Haoxuan You and Zhecan Wang and Zhicheng Wang and Erjin Zhou and Yue Gao},
      year={2021},
      eprint={2106.04051},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
```
mypythonlibpooja 0.1.0
My first Python library
License: MIT

Calculate the great circle distance between two points on the 
    earth (specified in decimal degrees), returns the distance in
    meters.
    All arguments must be of equal length.
    :param lon1: longitude of first place
    :param lat1: latitude of first place
    :param lon2: longitude of second place
    :param lat2: latitude of second place
    :return: distance in meters between the two sets of coordinates
clisy 0.0.4
A command line utility to search from command line using various search options and then open browser to see the results.
License: MIT

======
clisy
======

A command line utility to open browser for when you want to search something across various search options

Description
============

This is a simple utility to open browser from command line when you want to search something from various search options. Currently, it supports DuckDuckGo. But quickly, will plan to add the following options as well :

* DuckDuckGo ("ddg")
* GOOGLE ("g")
* WIKIPEDIA ("w")
* WIRECUTTER ("wc")
* AMAZON ("a")
* CREATIVE_COMMONS ("cc")
* IMDB ("imdb")
* SWIGGY ("sw")

Installation
=============
Run the following command to install clisy
::

    pip install clisy

Once ``clisy`` is installed, you get a command line utility called ``clisycp``.

Usage
=====
It is simple command line utility. To see the usage, you can type the following
::

    clisycp -h

Alternatively, here is the usage from version ``0.0.3`` so far
::

    usage: clisycp [-h]
               [--ddg <query_string> | -g <query_string> | -w <query_string> | --wc <query_string> | -a <query_string> | --cci <query_string> | --imdb <query_string> | --sw <query_string>]
               [-v] [-vv]

    CLI Search

    optional arguments:
      -h, --help            show this help message and exit
      --ddg <query_string>, --duck-duck-go <query_string>
                            Search in DuckDuckGo
      -g <query_string>, --google <query_string>
                            Search in Google
      -w <query_string>, --wikipedia <query_string>
                            Search in Wikipedia
      --wc <query_string>, --wirecutter <query_string>
                            Search in Wirecutter
      -a <query_string>, --amazon <query_string>
                            Search in Amazon
      --cci <query_string>, --creative-commons-image <query_string>
                            Image Search in Creative Commons
      --imdb <query_string>
                            Search in IMDb
      --sw <query_string>, --swiggy <query_string>
                            Search in Swiggy
      -v, --verbose         set loglevel to INFO
      -vv, --very-verbose   set loglevel to DEBUG

.. _pyscaffold-notes:

Note
====

This project has been set up using PyScaffold 4.0.2. For details and usage
information on PyScaffold see https://pyscaffold.org/.