Saravanan666/pypi-org huggingface dataset:
Package: create-case-folder
create-case-folderA command line script for creating a parent folder and sub-folders for case management.UsageTo use the script, run the following command in your terminal:create-case-folder--caseF01-66--evidenceEV01orcreate-case-folder-cF01-66-eEV01EV02EV03The--caseargument is optional and will default toYYYYMMDDHHmmss_NEWCASEif not provided.The--evidenceargument is also optional and will default toEVIDENCEif not provided.The script will create the parent folder and sub-folder for evidence, and then create the following sub-folders inside the evidence folder:DocumentsExtractsPicturesVideosReportsIf the folders are successfully created, the script will output a success message.If there's an error, the script will output an error message with the exception.ExampleContributingFeel free to fork the repository and make any changes or improvements that you'd like to see. If you have any questions or suggestions, please don't hesitate to reach out tojaytrairat@outlook.com.
Package: create-cohere-connector
Create Cohere ConnectorGenerates a custom Cohere Connector with one command.Cohere Connectorsenable to combine Cohere's large language models (LLMs), which power theChat API, with up-to-date factual information. They enhance Cohere's retrieval augmented generation (RAG) offering, and can respond to user questions and prompts with substantive, grounded generations that contain citations to external public or private knowledge bases.Note that this is an experimental project. If something doesn’t work, pleasefile an issue.You might also refer to the official Cohere repo for Connectors:https://github.com/cohere-ai/quick-start-connectors🧮 What is included?Your environment will have everything you need to quickly prototype and deploy a custom Cohere Connector:API serviceimplementing the requiredsearchendpoint usingFastAPI(support forFlaskis planned).Bearer Token Authenticationusing the Authorization header in HTTP requests.Pydantic modelsfor data validation and serialization.Client classto retrieve data from a custom data source.Deploy scriptto register your connector with Cohere.🚀 QuickstartInstallcreate-cohere-connectorpackage:You might install this package globall:poetryselfaddpoetry-scaffoldor within a virtual environment:# Windowspy-mvenv.venv
.venv\scripts\activate# macOS/Linuxpython3-mvenv.venvsource.venv/bin/activatepip3installcreate-cohere-connectorBootstrap your project:poetryruncreate-cohere-connectorThis will prompt for a project name:Projectname[myconnector]:hello-connector
Apiframework[FastAPI]:FastAPI
Authentication[Bearer]:Bearer
Caching[None]:Nonegenerate the initial project structure:myconnector
├── README.md
├── deploy.py
├── Dockerfile
├── pyproject.toml
├── poetry.lock
├── .gitignore
└── provider
    ├── __init__.py
    ├── app.py
    ├── config.py
    ├── client.py
    ├── provider.py
    ├── exceptions.py
    └── datamodels.pyand install dependencies:✅Projectcreatedsuccessfully!Set environment variablesYou might rename.env_templateto.env, and complete it.Span a shell within the virtual environmentpoetryshellInstall dependenciespoetryconfigvirtualenvs.in-projecttruepoetryinstall--no-rootStart API servicepoetryrunuvicornapp:app--app-dirprovider--port5000--reloadDeploy Cohere Connectorpythondeploy.py👩‍💻 ContributionsIf you would like to contribute, here are some features that we are planning to add:Improve Poetry virtual environment creationFlask supportSemantic cachingOAuth 2.0Data models scaffolding⚖️ LicenseCreate Cohere Connector is open source software licensed as Apache 2.0.
Package: create-dara-app
Create Dara AppBuild decision apps in PythonTap into the power of causality by transforming data into interactive graphs and applicationsDara is a dynamic application framework designed for creating interactive web apps with ease, all in pure Python. Over the past two years, Dara has fueled the development of hundreds of apps, now widely used and appreciated by both our customers and our in-house teams!QuickstartTo install the package, run:pipinstallcreate-dara-appThat's it! You can now use thecreate-dara-appCLI tool to create a new app.create-dara-app
Package: create-dash-app
create-dash-appcreate-dash-appis a utility for creating a boilerplateDashapplications.Why?I made this primarily because I wanted an easy way to initialize a Dash application that logically separates code.If you're new to Dash, the docs lead you down a design path of single file apps. This may be fine for their simple
examples, but in the real world your application will quickly grow untenable as you build out more complex views.I personally have run into this issue at least 2 times, and because I find refactoring to be a tedious chore,
I decided to build a tool to address it. I even added some other features because I'm just such a nice guy.InstallingInstallation is simple withpipor your preferred package manager.python-mpipinstallcreate-dash-appTo test the installationpython-mcreate_dash_app-hRunningRunning is also simple and can be done in one of two ways:To use the executable:create-dash-appTo run via python:python-mcreate_dash_appStructureThe main point of this package is to lay out your new app in a helpful structure, so let's take a moment to
review this snazzy structure.dash_app
├──__init__.py
├── app.py
├── assets
│   ├── dash.min.css
│   └── dbc.min.css
├── callbacks
│   ├──__init__.py
│   └── index.py
├── components
│   ├──__init__.py
│   └── index.py
├── server.py
└── wsgi.pyThis layout should intuitively make sense if you are familiar with Dash, but if you are a newbie or you can't
read my mind here is a file/folder level breakdown.Root Level Filesapp.pyYour entrypoint to the Flask development server:pythondash_app/app.pyTypically, you won't have to touch this file.server.pyDash app configuration and cache configuration live here.wsgi.pyA clean entrypoint if you run dash via a wsgi server (which you should be doing). For example:gunicorndash_app.wsgi-b:8050AssetsThis folder contains any static assets (CSS, images, JavaScript, etc.) you want to host. Readthis pagefor more information on theassetsfolder.CallbacksAll of your callback definitions should live here.callbacks.indexis imported byapp.pyto prevent any circular
dependency issues with theDashobject. It also means that if you create additional callback files, you only have
to import them incallbacks.indexand they will flow through to your app.ComponentsAll of your components definitions should live here, withcomponents.index.Layoutacting as the highest levelDiv.
Similar to the callback directory, if you create additional component files you only need to make their components
children ofLayout.
Package: create-django-app
Even though I rarely create new django apps from scratch, I still don’t like initial procedure of creating it, too much steps that can be automated. That’s the purpose of this tool.What this script does:Creates Django projectCreates corresponding appsCreates initial virtualenv (venv)Installs provided dependenciesCreates initial requirements.txtInitializes git repositoryRuns initial migration (using sqlitedb)Creates superuserShows created application in browserDownload and run the script:Python version:Download it from PyPi:pip3installcreate-django-app--userUsage:# show helpcreate-django-app--help# create django projectcreate-django-app-ptest_project-a'test_app1 test_app2'-drequests# create project without admin user with --noadmin flagcreate-django-app-ptest_project-a'test_app1 test_app2'-drequests--noadmin# don't run server in the end with --nodemo flagcreate-django-app-ptest_project-a'test_app1 test_app2'-drequests--nodemoBash version:DEPRECATED: this script does not recieve same updates as the python package, buy still gets the job done.
You can download it via wget/curl/whatever you prefer:curl-Ohttps://raw.githubusercontent.com/arsenlosenko/create-django-app/master/create-django-app.shAfter that give it executable permission:chmod+xcreate-django-app.shAnd run it:./create-django-app.sh-dfoo_project-a'foo_app bar_app'-d'requests'Show help:./create-django-app.sh
Package: create-doc
create_docGenerate angular project documentation using GPT and dependency-cruiser.Free software: MIT licenseFeaturesCreate documentation for your project using GPT. Analyze html files or other file types and generate a markdown file with the documentation.Create module dependency documentation using dependency-cruiser static code analysis.InstallationInstall the package with pip:pip install create_docDefine the following environment variables:OPENAI_API_KEY: Your OpenAI API keyInstall the following tools used by the processors:Install dependency-cruiser in the project you want to analyzenpm install dependency-cruiseror install dependency-cruiser globally to use it in other projects (it will show some warnings during processingnpm install -g dependency-cruiserUsageInitialize a project with the following command:create_doc initCheck the configuration file.create_doc.jsoncreated in the root of your project and adjust it to your needs. You can define multiple processors for gpt and dependencies.Create documentation for your project the following command:create_doc gpt-processYou can also run the specific gpt processors with the following commands:create_doc gpt-process processor_namefor examplecreate_doc gpt-process formsCreate documentation for your project dependencies with the following command:create_doc analyze-dependenciesTo run the specific dependency processors use the following commands:create_doc analyze-dependencies processor_nameCreditsOpenAI API is used to generate the documentation.OpenAI API:https://openai.com/Dependency-cruiser is used to analyze the dependencies of the project.Dependency-cruiser:https://github.com/sverweij/dependency-cruiserExample angular form fromhttps://github.com/gothinkster/angular-realworld-example-appThis package was created with Cookiecutter_ and theaudreyr/cookiecutter-pypackage_ project template.Cookiecutter:https://github.com/audreyr/cookiecutteraudreyr/cookiecutter-pypackage:https://github.com/audreyr/cookiecutter-pypackageHistory0.1.0 (2023-03-25)First release on PyPI.0.1.2 (2023-03-27)Improved GPT documentation generation.
Package: create-docker-compose
Index1Description2Version History3How to install4How it works4.1How to create a docker-compose.yml file4.2How to create a .env file5How to update this package6Example Files6.1docker-config.yml example6.2env_config.json example1. DescriptionThis package creates a docker-compose.yml and a .env file by combining multiple application's docker services and environment variables.2. Version HistoryLatest Version: 0.33. How to installRun the following command in your terminal:pip install create-docker-compose==0.14. How it works4.1 How to create a docker-compose.yml fileFor each application that you want to include in your docker-compose.yml file, you need to create a file called
docker-config.yml with the relevant services required for that app. You directory structure would look something
like this:An example of a docker-config.yml file can be found at theend of the readme atOnce all your docker-config.yml files have been created, run the following command at your projects root directory:create_docker_composeIt will then compile all the services in all your docker-config.myl files into a single docker-compose.yml file as highlighted
in the directory structure above.4.2 How to create a .env fileFor each application that you want to include in your .env file, you need to create a file called
env_config.json with the relevant environment variables required for that app. You can refer to the previous directory structure again.An example of a env_config.json file can be found at theend of the readme atOnce all your docker-config.yml files have been created, run the following command at your projects root directory:create_env_fileIt will then compile all the environment variables in all your env_config.json files into a single .env file as highlighted
in the directory structure above.5. How to update this packageTo update your package on PyPI, youâ€™ll need to make the desired changes to your package (e.g. update the code, add new files, etc.), update the version number in your setup.py file, and then rebuild and re-upload your package using the same commands as before:python setup.py sdist bdist_wheel
twine upload dist/*Make sure to increment the version number in your setup.py file before uploading the new version of your package. This will allow users to distinguish between different versions of your package and upgrade to the latest version using pip install --upgrade hello.6. Example Files6.1 docker-config.yml exampleyour-project-frontend:
build:
    context: ./Your Project/Frontend
container_name: your-project-frontend 
stdin_open: true
environment:
    - CHOKIDAR_USEPOLLING=true
    - WDS_SOCKET_PORT=0
    - PORT=3002

volumes:
    - ./Your Project/Frontend:/code
    - '/code/node_modules'
ports:
    - 3000:3000
networks:
    - docker-network6.2 env_config.json example{
    "DJANGO_ALLOWED_HOSTS": [
        "192.34.0.78",
        "localhost",
        "neura-dbms-backend"
    ],
    "DJANGO_ALLOWED_ORIGINS": [
        "http://localhost:7003",
        "http://localhost:3003"
    ],
    "SECRET_KEY_DBMS": "'secret_key'",
    "JWT_KEY": "'secret_key'"
}
Package: create-drf-app
create-drf-app toolcreate-drf-app helps you create Django + DRF project. choosing the type of template you want from basic to advance.InstallationsAssuming you have Python installed..
Install create-drf-app tool.$pipinstallcreate-drf-appCreate proejctCreate a new Django + DRF project.$create-drf-appstart<template_type>Template typesfor now we only have a basic templatebasicintermediateadvanceRoad mapIntermediate DRF templateAdvance DRF templateReact/DRF templateVue/DRF templateSolidJs/DRF templateLicenseEverything inside this repository isMIT licensed.
Package: createdryverail
Create Dryve RailThe following library is to be used for translation along the x-axis of a track controlled by the Dryve D1.Movement of the platform along the x-axis can be done with the:targetPosition(<point>)The point is set in reference to thehomeposition set at the negative end-switch.
As the end-switch's home position is then set to x = 0 at the designatedhomeposition, any input into the function is considered as relative to the universal frame set at this position.
Thehomeposition will begin to be set with:dryveInit()To manually set this position for any reason, simply run:homing()To get current position of the Dryve rail, simply use:getposition(<position(mm)>)As indicated, the function returns position of the rail at execution in millimetres.To set velocity profile, simply run:velocityProfile(<velocity(mm/s)>)Likewise, the target velocity can be set with:targetVelocity(<velocity(mm/s)>)The difference between velocity profile and target velocity is that targetvelocity() simply moves a set velocity
until a new command is set, while velocityProfile() simply modifies the velocity setting in point to point movement.If createdryverail contributes to a project that leads to publication, please acknowledge this by citing createdryverrail.
Package: create-eel-app
Create Eel Appcreate_eel_app provides basic template and managing utilities for an Eel app.Eel is a little Python library for making simple Electron-like HTML/JS GUI apps.Check out Eel here:https://github.com/samuelhwilliams/EelUsageCreate an Eel app$ create_eel_app.py create my_awesome_eel_appThis creates a directory with the namemy_awesome_eel_appin the current working directory and initializes a git repository as well.Launch the appIn the directory of the newly created app$ create_eel_app.py launchPackage the appTo package the app, simply run$ create_eel_app.py publishThis will package your file into a single file usingpyinstallerand put the resulting file indist/To change publishing settings, seeapp_config.jsonInstallationInstall it from pypi usingpip$ pip install create-eel-appor from source$ git clone https://github.com/gr3atwh173/create-eel-app
$ cd create-eel-app
$ python setup.py installTodoImplement basic templateImplement launchImplement publishMore templateshot reloading ðŸ”¥
Package: create-empty-image
Creates new/empty cv2 images/numpy arrays$pipcreate-empty-imagefromcreate_empty_imageimportcreate_new_image,create_new_image_same_sizea=create_new_image_same_size(openimage=r"https://github.com/hansalemaos/screenshots/raw/main/papag_00000003.png",color=(255,255,0),# rgb)b=create_new_image(width=200,height=300,color=(0,0,120,255))# rgbac=create_new_image(width=200,height=300,color=(120,))# gray
Package: create-fastapi
Create FastAPI AppCreate FastAPI App is a command-line tool that allows you to quickly set up a new FastAPI project with a predefined
directory structure and configurations. Inspired bycreate-react-appfor React projects, this tool aims to simplify
the initial setup process and get you up and running with FastAPI in no time.Table of ContentsFeaturesPrerequisitesInstallationUsageProject StructureContributingLicenseFeaturesRapid Setup: Create a new FastAPI project effortlessly without worrying about the initial project structure and
configurations.Ready-to-Code: Start coding your FastAPI application right away without spending time on boilerplate code.PrerequisitesBefore using Create FastAPI App, you need to have the following tools installed on your system:Python (3.6 or higher)Pip (Python package manager)InstallationYou can install Create FastAPI App usingpipx. Open your terminal or command prompt and run the following command:pipx install create-fastapiUsageTo create a new FastAPI project, use thecreate-fastapi-appcommand followed by the desired project name:my-fastapi-appcreate-fastapi-appmy-fastapi-appBy default, this will create a new FastAPI project in a directory namedmy-fastapi-appOnce the project is created, navigate to the project directory and start the development server:cd my-fastapi-apppython main.pyProject structureapp: This directory contains the main application code.main.py: Defines the main FastAPI application, including routes and endpoints.models: Directory for data models and Pydantic schemas.routes: Directory for organizing different API routes.utils: Directory for utility functions and modules.tests: Contains test files to verify the application's functionality..env: Environment variables file to store sensitive or configuration-specific data..gitignore: Specifies the files and directories to be ignored by version control (e.g.,.env,__pycache__/,
etc.).requirements.txt: Lists the project dependencies needed to run the FastAPI application.Testingpytest .Lintingruff .ContributingContributions are welcome! If you find any issues with the tool or want to suggest enhancements, please create a GitHub
issue or submit a pull request.LicenseCreate FastAPI App is open-source software licensed under theMIT License.
Package: create-fastapi-app
Create FastAPI App (cfa)Create and manage FastAPI applicationsQuick TourFollow these steps to set up a FastAPI project. See thedocumentationfor more details.InstallationThis is apip package. Thus, the only thing you need to do, is to run:pipinstallcreate-fastapi-appUsageTo create a new applications at a directory~/my_fastapi_dir, run:cfacreate~/my_fastapi_dirOptionsAuthYou can choose from three auth setups:none - no auth (default)self - self-managed authcfacreate~/my_fastapi_dir--auth=selfWill create auserstable and auth mechanisms for authorizing requestsbackend - auth managed by other backendcfacreate~/my_fastapi_dir--auth=backendWill create a logic for authorizing requests via external backend API. Remember to set theBACKEND_URLenv var, as well as theGET_USER_BY_TOKEN_ENDPOINTenv variable.When trying to authorize, by default the app will call an endpoint athttp://{BACKEND_URL}/{GET_USER_BY_TOKEN_ENDPOINT}/{token}. Make sure to have this endpoint and it returns a user object (with name, surname, email, etc)
Package: create-fast-app
create-fast-appcreate-fast-appis a Python package that helps you quickly create new FastAPI projects with basic templates. It includes a command-line interface (CLI) that lets you specify the type of project you want to create, as well as options to attach a machine learning directory.InstallationTo use create-fastapi-app, you must have Python 3.7 or later installed on your system. You can install the package using pip:pipinstallcreate-fast-appUsageTo create a new FastAPI project, run the following command:create-fast-app <project-name> --type=<project-type>Replace<project-name>with the desired name for your new project. The--typeoption is used to specify the type of project you want to create. There are three options available:microservice: Creates a FastAPI microservice project.monolith: Creates a FastAPI monolith project.ml_app: Creates a FastAPI machine learning project.By default, the --type option is set to microservice.You can also include the --ml option to attach a machine learning directory to your project. This option is only available for microservice and monolith project types.For example, to create a FastAPI monolith project with a machine learning directory attached, run:create-fast-app my-project --type=monolith --ml=TrueAfter running the command,create-fast-appwill create a new directory with your project name in the current working directory. It will then copy the appropriate FastAPI project template and install the required dependencies in a new virtual environment.Project StructureThe directory structure for each project type is as follows:Microservicemicroservice-project-1/
├── requirements/
│   ├── base.txt
│   ├── dev.txt
│   └── prod.txt
├── src/
│   ├── internal/
│   │   └── ...
│   ├── __init__.py
│   ├── app.py
│   ├── database.py
│   ├── models.py
│   ├── schemas.py
│   └── utils.py
├── tests
├── Dockerfile
├── README.md
├── Makefile
├── .env
├── .gitignore
└── venvMonolithmonolith-project-1/
├── requirements/
│   ├── base.txt
│   ├── dev.txt
│   └── prod.txt
├── src/
│   ├── package_one/
│   │   ├── config.py
│   │   ├── constants.py
│   │   ├── dependencies.py
│   │   ├── exceptions.py
│   │   ├── router.py
│   │   ├── schema.py
│   │   ├── service.py
│   │   └── utils.py
│   ├── internal/
│   │   └── ...
│   ├── __init__.py
│   ├── main.py
│   ├── config.py
│   ├── database.py
│   ├── models.py
│   └── utils.py
├── tests
├── Dockerfile
├── README.md
├── Makefile
├── .env
├── .gitignore
└── venvMachine learningml-project-1/
├── data/
│   ├── raw
│   └── processed/
│       ├── train
│       └── test
├── models
├── notebooks
├── src/
│   ├── data/
│   │   └── make_dataset.py
│   ├── feature/
│   │   └── build_features.py
│   ├── models/
│   │   ├── predict.py
│   │   └── train.py
│   └── utils.py
├── Dockerfile
├── README.md
├── Makefile
├── .env
└── .gitignoreIf attached to a monolith or a microservice project, this directory is mounted into the internal directory of the project.