semvec/pypi-packages huggingface dataset:
libs-shopee 0.0.13
A small example package
Requires Python: >=3.6


# Make sure you have upgraded version of pip
Windows
```
py -m pip install --upgrade pip
```

Linux/MAC OS
```
python3 -m pip install --upgrade pip
```

## Create a project with the following structure
```
packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── src/
│   └── example_package/
│       ├── __init__.py
│       └── example.py
└── tests/
touch LICENSE
touch pyproject.toml
touch setup.cfg
mkdir src/mypackage
touch src/mypackage/__init__.py
touch src/mypackage/main.py
mkdir tests
```

## pyproject.toml 

This file tells tools like pip and build how to create your project

```
[build-system]
requires = [
    "setuptools>=42",
    "wheel"
]
build-backend = "setuptools.build_meta"
```
build-system.requires gives a list of packages that are needed to build your package. Listing something here will only make it available during the build, not after it is installed.

build-system.build-backend is the name of Python object that will be used to perform the build. If you were to use a different build system, such as flit or poetry, those would go here, and the configuration details would be completely different than the setuptools configuration described below.


# Setup.cfg setup
Using setup.cfg is a best practice, but you could have a dynamic setup file using setup.py

```
[metadata]
name = example-pkg-YOUR-USERNAME-HERE
version = 0.0.1
author = Example Author
author_email = author@example.com
description = A small example package
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
    Bug Tracker = https://github.com/pypa/sampleproject/issues
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License
    Operating System :: OS Independent

[options]
package_dir =
    = src
packages = find:
python_requires = >=3.6

[options.packages.find]
where = src

```
# Running the build
### Make sure your build tool is up to date
Windows
```
py -m pip install --upgrade build
```
Linux/MAC OS
```
python3 -m pip install --upgrade build
```


### Create the build
```
py -m build
```

### Upload to pypi
```
twine upload dist/*
```














### References
https://packaging.python.org/tutorials/packaging-projects/
pymarchenko 0.2.0
A bag of Marchenko algorithms implemented on top of PyLops
Keywords: geophysics,inverse problems,seismic

# PyMarchenko

This Python library provides a bag of Marchenko algorithms implemented on top of [PyLops](https://pylops.readthedocs.io).

Whilst a basic implementation of the [Marchenko](https://pylops.readthedocs.io/en/latest/api/generated/pylops.waveeqprocessing.Marchenko.html#pylops.waveeqprocessing.Marchenko)
algorithm is available directly in PyLops, a number of variants have been developed over the years. This library aims at collecting
all of them in the same place and give access to them with a unique consistent API to ease switching between them and prototyping new
algorithms.

## Objective
Currently we provide the following implementations:

- Marchenko redatuming via Neumann iterative substitution (Wapenaar et al., 2014)
- Marchenko redatuming via inversion (van der Neut et al., 2017)
- Rayleigh-Marchenko redatuming (Ravasi, 2017)
- Internal multiple elimination via Marchenko equations (Zhang et al., 2019)
- Marchenko redatuming with irregular sources (Haindl et al., 2021)

Alongside the core algorithms, these following auxiliary tools are also provided:

- Target-oriented receiver-side redatuming via MDD
- Marchenko imaging (combined source-side Marchenko redatuming and receiver-side MDD redatuming)
- Angle gather computation (de Bruin, Wapenaar, and Berkhout, 1990)


## Getting started

You need **Python 3.6 or greater**.

#### From PyPi

```
pip install pymarchenko
```

#### From Github

You can also directly install from the main repository (although this is not reccomended)

```
pip install git+https://git@github.com/DIG-Kaust/pymarchenko.git@main
```

## Documentation
The official documentation of PyMarchenko is available [here](https://dig-kaust.github.io/pymarchenko/).

Visit this page to get started learning about the different algorithms implemented in this library.

Moreover, if you have installed PyMarchenko using the *developer environment* you can also build the documentation locally by
typing the following command:
```
make doc
```
Once the documentation is created, you can make any change to the source code and rebuild the documentation by
simply typing
```
make docupdate
```

Our documentation is hosted on Github-Pages and created with a Github-Action triggered every time a commit is made
to the main branch.
ez-i18n 0.0.1
A custom i18n implementation that is built to be easily used.
Keywords: python,i18n,translation,localisation,localization


# ez-i18n
 An easy implementation of i18n into Python.

--------
## Setting up
 Start by downloading the package via pip.
 ```
 python3 -m pip install ez-i18n
 ```

 After that, you can just import it into your file.

--------
## Examples
 ```py
 import ez-i18n
 import random
 from typing import Literal

 _ = ez-i18n.Translator() # if you don't provide anything in the brackets, it will look for the file's name's language JSON file. If the main file is main.py, it will look for main_lang.json - unless you provide a base filename (in this case: main) and/or a suffix (by default: _lang)
 dice = random.randint(1, 6)
 language = input("What's your native language? / Was ist Deine Muttersprache? (en/de) >>> ")

 print(_("dice_result", language, dice=dice))
 ```
 ```json
 {
    "en": {
        "dice_result": "Your dice rolled {dice}!"
    },
    "de": {
        "dice_result": "Dein Würfel hat eine {dice} gewürfelt!"
    }
 }
 ```

 

-------
## Working with plurals
 ```py
 import ez-i18n
 import locale

 _ = ez-i18n.Translator("main", "_plurals") # this will look for main_plurals.json as the language JSON file
 apples = int(input("How many apples do you have? >>> "))
 language = locale.getdefaultlocale()[:2] # this will return the default OS language, such as en, hu, de, fr, es etc.

 print(_.one("apples", language, apples=apples))
 ```
 ```json
 {
    "en": {
        "apples": ["You only have one apple! What a loser...", "You have {apples} apples!"]
    },
    "hu": {
        "apples": ["{apple} almád van!"]
    }
 }
 ```

 This example does a great job at presenting how the `.one()` function works. Here's the explanation for the code:
 The code will look for the default OS language, and will tell you how many apples you have with plurals in mind. I always get angry when I see "you have 1 apples"-ish text on a website, and it's an easy fix, but for some reason, many developers don't pay attention to it.
 Hungarian doesn't make a difference between plurals, so the list for "hu"/"apples" only has 1 item. This won't be a problem though - the library isn't hardcoded to only look for the first and second elements in the returned list, it will look for the **first** and the **last**. Which means that if a list only has 1 item, it will only return that item.
lgtm-lint 1.0.3
A fully featured 'Looks good to me!' linter.
Requires Python: >=3.7

[![PyPI version](https://badge.fury.io/py/lgtm-lint.svg)](https://badge.fury.io/py/lgtm-lint)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/lgtm-lint?style=plastic)
 [![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)

# LGTM Linter
Looks good to me! This is a satirical "linter" that doesn't actually assert or check anything. Linters have become so picky and opinionated that we thought it might be refreshing to have one that is happy with your code just the way it is!


## Python Install
You can install this package via PyPI with the following command:
```bash
pip install lgtm-lint
```
This will automatically add `lgtm-lint` to your path.


## Legacy Install
Just run the following:
```bash
./legacy_install.sh
```
This will install the script in your user bin. Also, Python3 is required to run the linter.

## Usage
Execute the linter over any code you'd like linted! You can do this by running the following:
```bash
lgtm-lint *
```
Or a more specific file or directory, up to you.