semvec/pypi-packages huggingface dataset:
robothon2021 1.1.6
citi trading bot robothon participation package
Requires Python: >=3.6, <4

# A sample Python project

![Python Logo](https://www.python.org/static/community_logos/python-logo.png "Sample inline image")

A sample project that exists as an aid to the [Python Packaging User
Guide][packaging guide]'s [Tutorial on Packaging and Distributing
Projects][distribution tutorial].

This project does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.

[The source for this project is available here][src].

Most of the configuration for a Python project is done in the `setup.py` file,
an example of which is included in this project. You should edit this file
accordingly to adapt this sample project to your needs.

----

This is the README file for the project.

The file should use UTF-8 encoding and can be written using
[reStructuredText][rst] or [markdown][md use] with the appropriate [key set][md
use]. It will be used to generate the project webpage on PyPI and will be
displayed as the project homepage on common code-hosting services, and should be
written for that purpose.

Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not a
good idea, although a simple “What's New” section for the most recent version
may be appropriate.

[packaging guide]: https://packaging.python.org
[distribution tutorial]: https://packaging.python.org/tutorials/packaging-projects/
[src]: https://github.com/pypa/sampleproject
[rst]: http://docutils.sourceforge.net/rst.html
[md]: https://tools.ietf.org/html/rfc7764#section-3.5 "CommonMark variant"
[md use]: https://packaging.python.org/specifications/core-metadata/#description-content-type-optional
botPlus 1.2.3
Set up a Python Discord bot quickly!
Keywords: python,discord,discord.py,bot,discord bot,quick

<h1 align="center">Bot Plus</h1>
<h3 align="center"><a href="https://pypi.org/project/botPlus/">Website</a></h3>

--- 

Set up a Python Discord bot quickly!

## Install:
To intall this package:
```console
$ pip install botPlus
```

## Set Up a simple bot:
```py
import discord
from discord.ext import commands
import botPlus

# Makes the bot 
client = botPlus.bot({'logging': 'advanced', "prefix": "!"})
bot = client.make()

# A command
@bot.command()
async def foo(ctx, arg):
    await ctx.send(arg)

# Runs the bot
client.run('')
```

## Docs:
Coming Soon
FredMD 0.0.6
Estimate factors off of the FRED-MD dataset
Requires Python: >=3.6

# FredMD
![Build](https://github.com/joe5saia/FredMD/workflows/FredMD%20Build/badge.svg)


This package downloads the [FRED-MD dataset](https://research.stlouisfed.org/econ/mccracken/fred-databases/) and estimates common factors. It also implements the [Bai-Ng (2002)](http://www.columbia.edu/~sn2294/pub/ecta02.pdf) factor selection information critrea. The alogrithms in this package are adapted from the matlab programs provided on the FRED-MD web page.

## Installation
This package can be installed via pip.

## Useage
```python
from FredMD import FredMD

fmd = FredMD(Nfactor=None, vintage=None, maxfactor=8, standard_method=2, ic_method=2)
fmd.estimate_factors()
f = fmd.factors
```

## References
* [Bai, Jushan and Ng, Serena (2002), "Determining the number of factors in approximate factor models"](https://onlinelibrary.wiley.com/doi/pdf/10.1111/1468-0262.00273).

* [McCracken, Michael W. and Ng, Serena (2015), "FRED-MD and FRED-QD: Monthly and Quarterly Databases for Macroeconomic Research"](https://research.stlouisfed.org/econ/mccracken/fred-databases/).


* [Bai, Jushan and Ng, Serena (2019), "Matrix Completion, Counterfactuals, and Factor Analysis of Missing Data"](https://arxiv.org/abs/1910.06677).
simpcli3 0.0.3
A Python3 library for turning functions into cmd-line programs trivially.
Requires Python: >=3.7
Keywords: cmd line command console argparse argparsing dataclass

# simpcli3
A Python3 module for turning functions into cmd-line programs trivially.


## Examples
### Non-dataclass (simple function) example
```
from simpcli3 import CliApp
from typing import List

def myls(paths: List[str], exclude: List[str]=[], mystr: str=None, follow_symlinks: bool=False):
    print(f"Received args: {paths}\n")
    for path in paths:
        print(path)

if __name__ == "__main__":
    CliApp(myls).run()
```

### More advanced Example
This example actually uses a dataclass argument rather than a collection of arguments of primitive types.

```
from dataclasses import dataclass, field
from enum import Enum
from typing import List

class PrintFormat(Enum):
    LINE_PER_ENTRY = 1
    PRETTY = 2

@dataclass
class ListDirectoryArgs:
    paths: List[str] = field(metadata=dict(positional=True))
    exclude: List[str] = field(default_factory=list)
    print_format: PrintFormat = PrintFormat.PRETTY
    follow_symlinks: bool = True

def myls(lsargs: ListDirectoryArgs):
    print(f"Received args: {lsargs}\n")
    for path in lsargs.paths:
        print(path)

if __name__ == "__main__":
    from simpcli3 import CliApp
    CliApp(myls).run()
```

## Looking Forward

It would be nice to also be able to parse JSON / TOML config files into dataclasses, rather than having ever-growing cmd-line args.

### Prior Art
And why I didn't use it.

For argparse_dataclasses and argparse_dataclass reasons, see Improvements.

SimpleParsing (pip install simple_parsing). Different goals and approaches in terms of simplicity. For one, we
don't depend on numpy.


#### Improvements over projects based on
Modifications made from "argparse_dataclass":
  2. "positional" metadata arg as I think that's more intuitive than passing "args" directly.
  3. If type is enum, choices automatically specified, default given as string
     (kind of like "argparse_dataclasses" package, but with cleaner impl IMO)
  4. Better handling of bools (especially ones which default to True).
  5. Wrapper over field (idea lifted from argparse_dataclasses)
yopto-api 0.0.2
Yopto API integration
Requires Python: >=3.7

# Yopto API 
This is a package to integrate and model the data 
structure and wrap the api calls made to use the 
yopto api.

## Install
```shell
pip install yopto-api
```
## Usage
### Authentication
To use the [yopto api](https://apidocs.yotpo.com/reference) you need to provide
your yotpo **api key** and **api secret** either by passing them as kwargs to 
the client init
```pyhton
client = YoptoClient(api_token, api_secret)
```
either by setting them as env vars named **YOPTO_API_TOKEN** and **YOPTO_API_SECRET**
so they are automatically used by the client when there kwargs are not provided.
```python
client = YoptoClient()
```
### Getting reviews
```python
client.get_reviews()
```
optionally providing the **product id** and the **from date** params.

### Creating reviews
```python
client.create_review(
        {
            "product_title": "product_title",
            "product_url": "https://www.sephora.com/something",
            "display_name": "John Doe",
            "email": "jone.dow@gmail.com",
            "review_content": "the fragrance is good, even thou the texture got worse, anyway, still great value.",
            "review_title": "great value",
            "review_score": 5,
        }
    )
```
npynx 1.0
web server
Keywords: web server

# npynx
twisted based http server with multiple domain support

## usage
from test/TestServer.py
```python
from jinja2 import Template
from npynx import Server, Domain, response


class DomainTest(Domain):
    root_template = Template("ON {{ ROOT }}")

    def root(self, *args):
        return response(body=self.root_template.render(content="/"))

    def another(self, *args):
        return response(body=self.root_template.render(content="/another"))

    def __init__(self):
        Domain.__init__(self, "127.0.0.1:4200", {
            "": self.root,
            "/": self.root,
            "/another": self.another,
        })


if __name__ == '__main__':
    server = Server("tcp:4200")
    domain_test = DomainTest()
    server.add_domain(domain_test)

    try:
        server.start()
        server.join()
    except KeyboardInterrupt:
        server.terminate()
```