Saravanan666/pypi-org huggingface dataset:
Package: cargo-venv
Cargo Virtual EnvironmentA virtual environment tool similar to Python's virtual environments.Table of ContentsInstallationUsageCustom toolchainIDE SupportIntelliJ IdeaInstallationpip install cargo-venvUsageLeveragingCargo's built-in command mechanism, you can simply call the following command to get a virtual environment calledvenv.cargo venvHowever, since this is a Python script, you can specify a different name by calling:cargo-venv custom-nameCustom toolchainYou can also specify a custom toolchain rather than always depend on the latest. If arust-toolchainfile is discovered
in your project, that version will be used to install the toolchain inside your virtual environment.IDE SupportIntelliJ IdeaUnderSettings > Languages and Frameworks > Rustset the following fields to these values:Toolchain Location<venv-path>/.rustup/toolchains/<toolchain-version>/binStandard library<venv-path>/.rustup/toolchains/<toolchain-version>/lib/rustlib/src/rust
Package: cargo-workspace
Cargo WorkspaceParse Rust Workspace files from aCargo.tomlfile.Examplefromcargo_workspaceimportWorkspace# Path can be a file or directory:workspace=Workspace.from_path('Cargo.toml')forcrateinworkspace.crates:print(f'crate at{crate.path}has name{crate.name}')Note that this crate uses getter functions instead of the conventionalMetadataThe metadata of each crate is accessible like so:meta=crate.workspace.get('some.custom.key')ifmetanotNone:print(f'custom metadata found:{meta}')
Package: cargo-xwin
cargo-xwinformerly cargo-xwinbuild🚀 Help me to become a full-time open-source developer bysponsoring me on GitHubCross compile Cargo project to Windows msvc target with ease.By using this software you are consented to accept the license athttps://go.microsoft.com/fwlink/?LinkId=2086102PrerequisiteFor pure Rust project, no prerequisites needed.For C/C++ dependencies, installclang(On macOS runbrew install llvmand you're good to go).For assembly dependencies, installllvm-tools-previewcomponent viarustup component add llvm-tools-previewor installllvm.Installationcargoinstallcargo-xwinYou can also install it using pip:pipinstallcargo-xwinWe also provide aDocker imagewhich has wine pre-installed in addition to cargo-xwin and Rust,
for example to build for x86_64 Windows:dockerrun--rm-it-v$(pwd):/io-w/iomessense/cargo-xwin\cargoxwinbuild--release--targetx86_64-pc-windows-msvcUsageInstall Rust Windows msvc target via rustup, for example,rustup target add x86_64-pc-windows-msvcRuncargo xwin build, for example,cargo xwin build --target x86_64-pc-windows-msvcRun tests with wineWith wine installed, you can run tests with thecargo xwin testcommand,
for example,cargo xwin test --target x86_64-pc-windows-msvcCustomizationThe Microsoft CRT and Windows SDK can be customized using the following environment variables or CLI options.Environment VariableCLI optionDescriptionXWIN_ARCH--xwin-archThe architectures to include, defaults tox86_64,aarch64, possible values: x86, x86_64, aarch, aarch64XWIN_VARIANT--xwin-variantThe variants to include, defaults todesktop, possible values: desktop, onecore, spectreXWIN_VERSION--xwin-versionThe version to retrieve, defaults to 16, can either be a major version of 15 or 16, or a<major>.<minor>versionXWIN_CACHE_DIR--xwin-cache-dirxwin cache directory to put CRT and SDK filesXWIN_INCLUDE_DEBUG_LIBS--xwin-include-debug-libsWhether or not to include debug libs in installation (default false).CMake SupportSome Rust crates use thecmakecrate to build C/C++ dependencies,
cargo-xwin will generate aCMake toolchainfile
automatically to make cross compilation work out of the box.ninjais requiredto enable CMake support.LicenseThis work is released under the MIT license. A copy of the license is provided
in theLICENSEfile.
Package: cargo-xwinbuild
cargo-xwinbuildCross compile Cargo project to Windows msvc target with ease. (LLVM installation required.)By using this software you are consented to accept the license athttps://go.microsoft.com/fwlink/?LinkId=2086102Installationcargoinstallcargo-xwinbuildYou can also install it using pip:pipinstallcargo-xwinbuildUsageInstallLLVM, on macOS:brew install llvmInstall Rust Windows msvc target via rustup, for example,rustup target add x86_64-pc-windows-msvcRuncargo xwinbuild, for example,cargo xwinbuild --target x86_64-pc-windows-msvcRun tests with wineWith wine installed, you can run tests with thecargo xwintestcommand,
for example,cargo xwintest --target x86_64-pc-windows-msvcCustomizationThe Microsoft CRT and Windows SDK can be customized using the following environment variables or CLI options.Environment VariableCLI optionDescriptionXWIN_ARCH--xwin-archThe architectures to include, defaults tox86_64,aarch64, possible values: x86, x86_64, aarch, aarch64XWIN_VARIANT--xwin-variantThe variants to include, defaults todesktop, possible values: desktop, onecore, spectreXWIN_VERSION--xwin-versionThe version to retrieve, defaults to 16, can either be a major version of 15 or 16, or a<major>.<minor>versionXWIN_CACHE_DIR--xwin-cache-dirxwin cache directory to put CRT and SDK filesCMake SupportSome Rust crates use thecmakecrate to build C/C++ dependencies,
cargo-xwinbuild will generate aCMake toolchainfile
automatically to make cross compilation work out of the box.ninjais requiredto enable CMake support.LicenseThis work is released under the MIT license. A copy of the license is provided
in theLICENSEfile.
Package: cargo-zigbuild
cargo-zigbuild🚀 Help me to become a full-time open-source developer bysponsoring me on GitHubCompile Cargo project withzigaslinkerforeasier cross compiling.Installationcargoinstallcargo-zigbuildYou can also install it using pip which will also installziglangautomatically:pipinstallcargo-zigbuildWe also provide aDocker imagewhich has macOS SDK pre-installed in addition to cargo-zigbuild and Rust,
for example to build for x86_64 macOS:dockerrun--rm-it-v$(pwd):/io-w/iomessense/cargo-zigbuild\cargozigbuild--release--targetx86_64-apple-darwinUsageInstallzigfollowing theofficial documentation,
on macOS, Windows and Linux you can also install zig from PyPI viapip3 install ziglangInstall Rust target via rustup, for example,rustup target add aarch64-unknown-linux-gnuRuncargo zigbuild, for example,cargo zigbuild --target aarch64-unknown-linux-gnuSpecify glibc versioncargo zigbuildsupports passing glibc version in--targetoption, for example,
to compile for glibc 2.17 with theaarch64-unknown-linux-gnutarget:cargozigbuild--targetaarch64-unknown-linux-gnu.2.17macOS universal2 targetcargo zigbuildsupports a specialuniversal2-apple-darwintarget for building macOS universal2 binaries/libraries on Rust 1.64.0 and later.rustuptargetaddx86_64-apple-darwin
rustuptargetaddaarch64-apple-darwin
cargozigbuild--targetuniversal2-apple-darwinNoteNote that Cargo--message-formatoption doesn't work with universal2 target currently.CaveatsCurrently only Linux, macOS and Windows gnu targets are supported,
other target platforms can be added if you can make it work,
pull requests are welcome.Only current Ruststableandnightlyversions are regularly tested on CI, other versions may not work.Known upstream zigissues:zig cc: parse-targetand-mcpu/-march/-mtuneflags according to clang:
Some Rust targets aren't recognized byzig cc, for examplearmv7-unknown-linux-gnueabihf, workaround by using-mcpu=genericand
explicitly passing target features in#58ability to link against darwin frameworks (such as CoreFoundation) when cross compiling:
Set theSDKROOTenvironment variable to a macOS SDK path to workaround itzig misses somecompiler_rtfunctionsthat may lead to undefined symbol error for certain
targets. See also:zig compiler-rt status.CPU features are not passed to clangLicenseThis work is released under the MIT license. A copy of the license is provided
in theLICENSEfile.
Package: cargparse
Parse configuration files withargparse.Supported file typestypereaderthird-partynote✅cfg/iniconfigparsernoSupports customConfigParserreader✅jsonjsonno✅tomltomli/tomllibyes/notomllibis built-in from Python 3.11 and was based ontomli✅yamlpyyamlyesInstallationpip install cargparseBasic usageGivenconfig.yaml:text:hello worldnumber:42Useargparseas you normally would for command line arguments!importargparseimportcargparseimportsysparser=argparse.ArgumentParser()parser.add_argument('--text',type=str,required=True)parser.add_argument('--number',type=int,required=True)parser.add_argument('--decimal',type=float)config=cargparse.Cargparse(parser).parse_file(sys.argv[1])python test.py config.yaml
>> config
{'text': 'hello world', 'number': 42)
>> config.text
'hello world'
>> type(config.number)
<class 'int'>⚠️ Read thedocumentationfor more information about type validation.Advanced usageYou are not restricted to a flat hierarchy.model:lstm:input_size:100hidden_size:-128-64summary:TrueDefine a helper function to parse each nested sectionargs, which is interpreted as a dictionarystr.from__future__importannotationsdefparse_config(filename:Path|str)->cargparse.Namespace:defmodel_namespace(args:str)->cargparse.Namespace:parser=argparse.ArgumentParser()parser.add_argument('--cnn',type=cnn_namespace)parser.add_argument('--lstm',type=lstm_namespace)parser.add_argument('--summary',type=cargparse.boolean)returncargparse.Cargparse(parser).parse_dict(args)defcnn_namespace(args:str)->cargparse.Namespace:parser=argparse.ArgumentParser()parser.add_argument('--in_channels',type=int,required=True)parser.add_argument('--out_channels',type=int,required=True)parser.add_argument('--kernel_width',type=int,required=True)returncargparse.Cargparse(parser).parse_dict(args)deflstm_namespace(args:str)->cargparse.Namespace:parser=argparse.ArgumentParser()parser.add_argument('--input_size',type=int,required=True)parser.add_argument('--hidden_size',type=cargparse.list_int,required=True)returncargparse.Cargparse(parser).parse_dict(args)parser=argparse.ArgumentParser()parser.add_argument('--model',type=model_namespace,required=True)returncargparse.Cargparse(parser).parse_file(filename)if__name__=='__main__':config=parse_config(filename=sys.argv[1])>> config.model.cnn
>> config.model.lstm.hidden_units
*** AttributeError: hidden_units not in namespace: ['hidden_size', 'input_size']
>> config.model.lstm.hidden_size
[128, 64]⚠️ Read thedocumentationfor more information about type validation.
Package: caribbean-outbreak-tracker
Caribbean Outbreak TrackerIntroductionDjango package for tracking pandemic outbreaks in the Caribbean. Based on previous project for tracking COVID-19 across the Caribbean (https://github.com/obikag/caribbean-virus-tracker/).Website based on this project can be found here:https://caribbeanvirustracker.com/InstallationPipUse the Python package managerpipto install the package and dependencies.pipinstallcaribbean-outbreak-trackerGitHub RepoClone the repo and navigate to the working directory.gitclonehttps://github.com/obikag/caribbean-outbreak-tracker.gitcdcaribbean-outbreak-trackerUsingsetuptoolsinstall the package and dependencies.pythonsetup.pyinstallUsageCreate aDjangoproject and navigate to working directory.django-adminstartprojectexample-sitecdexample-siteAdd the outbreak tracker app to you settings.py fileINSTALLED_APPS=[...,'outbreak_tracker',]Make migrations and migrate changes to the databasepythonmanage.pymakemigrations
pythonmanage.pymigrateNavigate to the project's admin site to access the models and enter the relevant information.DocumentationComming SoonTestingComming SoonContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT
Package: carica-cfn-tools
Simple command line tools to create and update CloudFormation stacks that
make it easy to version-control both your templates and stack configurations
in one place.  Supports a few proprietary transforms useful for dynamically
merging a manually maintained template with a generated template (for example,
sam.json from “chalice package”) that contains resources you’d like to include
in your main template.DevelopmentThevinstallscript uses thevenvmodule to prepare a Python environment useful
for development, so you don’t have to build and install carica-cfn-tools to be
able to run and test it.Run./vinstallActivate the virtual environment by running. ./venv/bin/activateTheconsole_scriptslisted insetup.pyare now in your path, so you
can simply run them like:carica-cfn...Sample Stack ConfigRegion: us-east-1
Bucket: mycorp-cfn-us-east-1
Name: WarehouseApp
Template: ../templates/warehouse-app.yml
Jinja: true
Parameters:
  # Normal parameter values can include strings, numbers, booleans, etc.
  Stage: dev
  TableReadCapacityUnits: 10
  TableWriteCapacityUnits: 5
  AdminPassword:
    # A parameter with a "ParameterStore" sub-key will be resolved to the
    # SSM Parameter Store parameter with that name.
    ParameterStore: dev.warehouseapp.admin-password
  PostgreSQLPassword:
    # A parameter with a "SecretsManager" sub-key will be resolved to the
    # Secrets Manager secret with that ID.
    SecretsManager: dev.warehouseapp.postgresql-password
Extras:
  - ../cfn/static/logo.png
  - ../cfn/static/index.html
JinjaExtras:
  - ../cfn/includes/*.yml
JinjaExtrasContext:
  FOO: barRegionsets where the CloudFormation template and related resources will be
uploaded and where the CloudFormation stack will be created.  This must match
the region theBucketwas created in.  This is required.Bucketsets where the CloudFormation template and related resources will be
uploaded.  This is required.Namesets the name of the CloudFormation stack.  This is required.Templateis a relative path to the CloudFormation YAML or JSON template
file to create the stack from.  This is required.Jinjais an optional setting that controls whetherTemplatewill be
processed with Jinja2 before being uploaded.  This setting does not enable
Jinja2 for extras; useJinjaExtrasfor that.ExtrasandJinjaExtrascan be absolute paths or glob patterns relative to
the stack config file.ExtrasorJinjaExtrasthat are directories, whether specified by absolute
path or expanded from a glob pattern, are copied recursively into the deployment
at a top-level directory named after thelastdirectory component of the source.
An extra directory path like/foo/bar/bazends up as/bazin the deployment.ExtrasorJinjaExtrasthat are files, whether by absolute path or expanded
from a glob pattern, are copied into the root of the deployment.JinjaExtrasare processed with the Jinja2 template engine after all extras
are copied to a temporary directory.JinjaExtrasContextis a dictionary passed as the context when Jinja is run.
Package: carica-dynamodb-tools
Simple backup and restore utilities for DynamoDB tables.DevelopmentThevinstallscript uses thevenvmodule to prepare a Python environment useful
for development, so you don’t have to build and install carica-dynamodb-tools to be
able to run and test it.Run./vinstallActivate the virtual environment by running. ./venv/bin/activateTheconsole_scriptslisted insetup.pyare now in your path, so you
can simply run them like:carica-dynamodb...
Package: carim-discord-bot
carim-discord-botA simple Discord bot that can communicate with BattlEye via RCon. Support can be found
in theCarim Discord.Table of ContentsInstallUpdateFeaturesUsageExamplesScheduled CommandsExamplesInstallInstall Python 3.7 or 3.8Runpip3 install carim-discord-botRuncarim-bot --setupand follow the instructionsAlternatively, you candeploy using Heroku.UpdateRunpip3 install carim-discord-bot -URuncarim-bot --setup configurationto see if any options have changedUpdate your configuration file accordinglyRestart the service if you have oneFeaturesLog RCon communication to DiscordSend RCon commands to the server via DiscordSchedule RCon commands to be executed by relative time or aligned with the clockSkip the next instance of a scheduled commandPerform safe shutdowns of the server, including kicking players and lockingEstablish cross-chat that links the in-game chat and a Discord channelUsagecommands:
--help                     displays this usage information
--about                    display some information about the bot
--version                  display the current version of the bot

admin commands:
--command [command]        send command to the server, or list
                           the available commands
--shutdown [seconds]       shutdown the server in a safe manner
                           with an optional delay; notice messages
                           are broadcasted to the server at
                           60, 30, 20, 10, 5, 4, 3, 2, and 1 minute
                           until shutdown
--status                   show current scheduled item status
--skip index               skip next run of scheduled command
--kill                     make the bot terminateExamples--command "say -1 Hello everybody!"
# this sends a message to everybody on the server
# notice the quotes around the command

--command players
# gets a list of currently connected players

--shutdown 3600
# schedules the server to be shutdown in an hourScheduled CommandsExamplesSend a global server message every 5 minutes{"command":"say -1 Hello everybody!","interval":300}Shutdown the server every 3 hours starting at 00:00{"command":"safe_shutdown","delay":3600,"interval":10800,"with_clock":true,"offset":3600}
Package: carinata
Carinata is a command line tool which transforms spec files into unittest cases.
It tries to be a bit like RSpec, but for python. It includes a management
command for Django.Spec files contain blocks calleddescribe,context,before,after,letandit, which in turn contain pure python. Carinata uses these blocks
to create aTestCasecorresponding to eachitblock, with the setup frombeforeandletand the teardown fromafter.See theproject homepageon GitHub for more information, but here is an example:describe "My Awesome class":
    context "with the number 42":
        let "awesome": Awesome(42)

        it "jumps for joy":
            assert self.awesome.jumps_for_joy()

    context "with a string":
        let "awesome": Awesome('wow!')

        it "says it":
            assert self.awesome.say() == "Awesome says 'wow!'"
Package: carkov
carkovThis is a library for creating and walking simple markov chains. It is
meant for things like text generators (such as ebooks bots and word
generators) and thus is not 'mathetematically correct'. It has some
tools for doing text analysis but more are planned in the future
(stubs exist to illustrate some plans, see TODO.md).Command line interfaceThis library includes a command line interface to analyzing text and
then walk the chain and generate text from the analysis.To analyze a corpus of text files, thus:carkov analyze mychain.chain textfile1.txt textfile2.txt ... textfileN.txtTo walk a chain and generate text form it, thus:carkov chain mychain.chain -c 10There are two analysis modes currently supported,englishandword, which are passed to the analyze method with the-margument.englishmode analyzes the input in a word-wise method: the
input is segmented into (English-style) sentences, each of which are
analyzed as separate chains of words.wordsegments the input into
tokens, each of which is analyzed as a series of characters
separately.Analysis also allows a window size to be specified, so that each item
in the chain may be a fixed series of items of a specific length (for
example, the wordfoowith a window of 2, would analyze to (_,) ->
'f', (, f) -> o, (f, o) -> o, etc). The wider the window, the more
similar or identical to the input stream the output becomes since
there are fewer total options to follow any given token. This is
specified with the analysis command line with the-wargument.About LibraryThe library itself exposes objects and interfaces to do the same as
the command line above. A todo item on this project is to generate
documentation and examples, but looking at the contents ofmain.py
should be instructive. The library is written in such a way as to be
pretty agnostic about the items that are chained, and hypothetically
any sequential set of things could work for this. Some framework would
have to be written to support displaying these sorts of things but it
should be possible if non-textual data were desired.The library also provides a few mechanisms for serializing a ready to
use chain for reuse in other projects. The command line makes use of
the binary serialization mechanism (which usesmsgpack) to save
chains from the analysis step for re-use in the chain step. There is
also a mechanism which produces a python source file tthat can be
embedded in a target project so that a python project can use the
chain without having to include an extra data file. It should be noted
that this of course is extremely inefficient for large chains.
Package: carla
This is the Python package for the CARLA Python API used for controlling and communicating-withCARLA- The open-source simulator for autonomous driving research.This package allows you to control the CARLA simulator and retrieve simulation data through the Python API. For instance, you can control any actor (vehicle, pedestrian, traffic light, etc...) in the simulation, attach sensors to vehicles, and read the sensor data etc.For more information, refer to theGuide for getting started with CARLA.
Package: carla-birdeye-view
Bird-eye's view for CARLAFreeway-oriented shapeLearning By Cheating-like shapeCenterlines layer(GIFs above present feature maps after applyingas_rgb()function)MotivationDuring ourresearchwe found a very inspiring paper calledLearning By Cheating.Bird-eye's viewis made specifically tolearn faster thanks to much simpler, 2D world representation(cheating oracle) which we think fits well inReinforcement Learningsetup.This repository is an almost complete reimplementation that gives better performance and compatibility with most recent versions of CARLA. You can use it out-of-the-box as input for your model, and if necessary convert and visualize into RGB.Featuresone-hot 3D feature map(8x2D layers, each representing other entities, e.g. road layer, pedestrians layer) - made specifically to feed your CNNfeature mapcan be converted to an RGBimagelayers can be easily removedcaching mechanism for static layers like: roads and lanesusingOpenCV rendering(efficient, multi-threading friendly) instead of slow Pygame methodhugeFPS speedupthanks to restricted rendering (only agent's surroundings, not whole map)all CARLA maps are supported out-of-the-box, custom maps with valid OpenDrive file made in RoadRunner are also supportedcurrent implementation is specifically  adjusted for highway scenarios (prolonged shape), but other shapes and crops are easy to implementInstallationpipinstallcarla-birdeye-viewHow to runMake sure thatPYTHONPATHenv variable contains CARLA distribution egg, so thatcarlapackage can be imported.# Launch server instance./CarlaUE4.sh# (optional) For CARLA 0.9.8+ you may get additional performance improvement with thispythonPythonAPI/util/config.py--no-rendering# Preview while cruising on autopilot (birdview/__main__.py)python-mcarla_birdeye_viewBasic code usagefromcarla_birdeye_viewimportBirdViewProducer,BirdViewCropType,PixelDimensionsbirdview_producer=BirdViewProducer(client,# carla.Clienttarget_size=PixelDimensions(width=150,height=336),pixels_per_meter=4,crop_type=BirdViewCropType.FRONT_AND_REAR_AREA)# Input for your model - call it every simulation step# returned result is np.ndarray with ones and zeros of shape (8, height, width)birdview=birdview_producer.produce(agent_vehicle=agent# carla.Actor (spawned vehicle))# Use only if you want to visualize# produces np.ndarray of shape (height, width, 3)rgb=BirdViewProducer.as_rgb(birdview)Contribution and feedbackWe'd :heart: to collct any feedback, issues and pull requests!CreditsProject born atdeepsense.ai, made by:Michał Martyniak (@micmarty)