Saravanan666/pypi-org huggingface dataset:
Package: enthought-sphinx-theme
Sphinxtheme forEnthought projects, derived from theScipy theme.InstallationInstall this as a normal Python package. The theme files are in the package
data.In your project’sconf.pyfile, do the following:import enthought_sphinx_theme
html_theme_path = [enthought_sphinx_theme.theme_path]
html_theme = 'enthought'Theme optionsThe theme takes the followin options in thehtml_theme_optionsconfiguration variable:rootlinksList of tuples(url, link_name)to show in the beginning of the
breadcrumb list on the top left. You can override it by defining anedit_linkblock insearchbox.html.sidebarOne of"left","right","none".  Defines where the sidebar
should appear.navigation_linksTrueorFalse. Whether to display “next”, “prev”, “index”, etc.
links.use_default_logoTrueorFalse. Whether to use the default Enthought logo in the
sidebar. If thehtml_logoconfiguration parameter is non-empty, it will
override this. Set this toFalseandhtml_logoto empty only if you
want no logo at all.use_default_faviconTrueorFalse. Whether to use the default Enthought logo as the
favicon.  If thehtml_faviconconfiguration parameter is non-empty, it
will override this. Set this toFalseandhtml_faviconto empty only
if you want no favicon at all.The following blocks are defined:layout.html:headerBlock at the top of the page, for logo etc.
Package: entities
Entities is a Python library for automated object validation and serialization.
It is useful in cases where you need well-defined entity models but you don’t
specifically need a storage backend or a form validator. It supports recursive
and non-recursive collection types (list, set and dict), nested entities and
reference fields. It can automatically validate, serialize, deserialize and
generate hashable keys for entities of any complexity.UsageTypical usage looks like this:from entities import *

class Account(Entity):
    id = IntegerField(group=PRIMARY)  # this field is in primary key group
    iban = IntegerField(group=SECONDARY)  # this is in secondary key group
    balance = FloatField(default=0.0)

class Name(Entity):
    first_name = StringField(group=SECONDARY)
    last_name = StringField(group=SECONDARY)

class Customer(Entity):
    id = IntegerField(group=PRIMARY)
    name = EntityField(Name, group=SECONDARY)
    accounts = ListField(ReferenceField(Account), default=[])

# Create Account objects.
a_1 = Account(1, 111, 10.0)  # __init__() recognize positional arguments
a_2 = Account(id=2, iban=222, balance=20.0)  # as well as keyword arguments

# Generate hashable key using primary key.
print a_1.keyify()  # prints '(1,)'

# Generate hashable key using secondary key.
print a_2.keyify(SECONDARY)  # prints '(222,)'

# Create Customer object.
c = Customer(1, Name('eser', 'aygun'))

# Generate hashable key using primary key.
print c.keyify()  # prints '(1,)'

# Generate hashable key using secondary key.
print c.keyify(SECONDARY)  # prints '(('eser', 'aygun'),)'

# Try validating an invalid object.
c.accounts.append(123)
try:
    c.validate()  # fails
except ValidationError:
    print 'accounts list is only for Account objects'

# Try validating a valid object.
c.accounts = [a_1, a_2]
c.validate()  # succeedsTODO ListJSON serialization module (should be pretty easy)BSON serialization module (for MongoDB compatibility)
Package: entity-addict
entity_addictAn extended version ofaddict.It can be very useful as a decorator.
It can be converted to Dict when the function returns a value.
Can support a single dictionary, list dictionary, or multi deep  dictionary of list.install via pippip install entiry_addictexamples:fromentity_addictimportentity_addict@entity_addictdefget_dict_data_a():return{"key_name":"value"}data=get_dict_data_a()print(data.key_name)@entity_addictdefget_dict_data_b():return[{"key_name":"value"}]fordatainget_dict_data_b():print(data.key_name)@entity_addictdefget_dict_data_c():return[{"key_name":"value"},{"key":[{"sub_key1":1},{"sub_key2":2}]}]data=get_dict_data_c()print(data[1].key[1].sub_key2)
Package: entity-classification
entity-classificationPerform Entity Classification via two inputs:entity_names: listandinput_tokens: listAssume you wish to classifynetwork_topologyand you have these tokens extracted from your text:['edge','network','moderate','cat5','topology','locate']Use this codefromentity_classificationimportclassifyclassify(entity_names=['network_topology'],input_tokens=input_tokens)The result will be{'result':['network_topology'],'tokens':['network','topology']}
Package: entityd
Entityd Monitoring Agent for Cobe.ioA daemon which monitors entities on a host system and streams them to
cobe.io.InstallationIt is recommended to get a binary conda-based distribution fromhttps://cobe.iowhich provides the entire Python environment
required.  Once you have created a Topology Instance there it will
offer to download an agent and provide installation instructions.However if you prefer you can install from PyPI as well, a few more
manual steps are needed.  The entityd package relies on some other
PyPI packages which may require install-time compilation depending on
your setup.  If your system has everything available then installation
is as simple as:pip install entitydAlternatively you may prefer to install into a virtualenv created just
for entityd, thepipsiproject makes this very convenient:pipsi install entitydConfigurationTo securely communicate with cobe.io you need to install encryption
keys which you can download from the agent installation page on
cobe.io.  There are two files to download,modeld.keyandentityd.key_secret, which need to be installed into anetc/entityd/keys/directory.  If you installed entityd into a
virtualenv, as recommended, then this directory is relative inside the
virtualenv, e.g.:/path/to/venv/etc/entityd/keys/.  You may have
to create the directory before moving the keys there.SystemdOnce installed you probably want to ensure it gets started
automatically.  This will depend on the init system in use by your
host.If you are usingsystemdyou can install the following unit file to/etc/systemd/system/entityd.service, being sure to provide the
correct path to the installed binary and the correct destination for
your Topology Instance:[Unit]
Description=Entityd monitoring agent for cobe.io
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/entityd --dest=tcp://modeld.example.cobe.io:25010

[Install]
WantedBy=multi-user.targetOnce the unit file is installed you can start entityd usingsystemctl start entityd.service.  To automatically start it on
system boot you also need to executesytemctl enable entityd.service.  If you modify the unit file be sure to executesystemctldaemon-reloadto re-read the configuration.
Package: entity-embeddings-categorical
OverviewThis project is aimed to serve as an utility tool for the preprocessing, training and extraction of entity embeddings through Neural Networks using the Keras framework. It's still under construction, so please use it carefully.InstallationThe installation is pretty simple if you have a virtualenv already installed on your machine. If you don't please rely toVirtualEnv official documentation.pipinstallentity-embeddings-categoricalDocumentationBesides the docstrings, major details about the documentation can be foundhere.TestingThis project is inteded to suit most of the existent needs, so for this reason, testability is a major concern. Most of the code is heavily tested, along withTravisas Continuous Integration tool to run all the unit tests once there is a new commit.UsageThe usage of this utility library is provided in two modes: default and custom. In the default configuration, you can perform the following operations: Regression, Binary Classification and Multiclass Classification.If your data type differs from any of these, you can feel free to use the custom mode, where you can define most of the configurations related to the target processing and output from the neural network.Default modeThe usage of the default mode is pretty straightforward, you just need to provide a few parameters to the Config object:So for creating a simple embedding network that reads from filesales_last_semester.csv, where the target name istotal_sales, with the desired output being abinary classificationand with a training ratio of0.9, our Python script would look like this:config=Config.make_default_config(csv_path='sales_last_semester.csv',target_name='total_sales',target_type=TargetType.BINARY_CLASSIFICATION,train_ratio=0.9)embedder=Embedder(config)embedder.perform_embedding()Pretty simple, huh?A working example of default mode can be foundhere as a Python script.Custom modeIf you intend to customize the output of the Neural Network or even the way that the target variables are processed, you need to specify these when creating the configuration object.
This can be done by creating a class that extend fromTargetProcessorandModelAssembler.A working example of custom configuration mode can be foundhere.VisualizationOnce you are done with the training of your model, you can use the modulevisualization_utilsin order to create some visualizations from the generated weights as well as the accuraccy of your model.Below are some examples created for theRossmann dataset:TroubleshootingIn case of any issue with the project, or for further questions, do not hesitate to open an issue here on GitHub.ContributionsContributions are really welcome, so feel free to open a pull request :-)TODOAllow to use a Pandas DataFrame instead of the csv file path;
Package: entity-everything
entity-everythingEasy to use tool for encoding text to html entities and html entities to normal text.✨ FeaturesEncoding & decoding of text passed as an argumentEncoding & decoding of text from the standard input📝 Project descriptionThere are plenty of online tools on the Internet for encoding text to html entities. However, the solutions i found have one thing in common: they only convert special characters, without changing letters and numbers.If for some reason you want to convert letters and numbers to entities as well, "entity-everything" is the script for you.💻 How to download?Project is available on PyPi, so you can install entity-everything using pip:$ python -m pip install entity_everything🔧 How to use?1️⃣ Encoding text:$ python -m entity_everything encode "Text to encode"
or
$ echo "Text to decoode" | python -m entity_everything encodeResult: "&#84;&#101;&#120;&#116;&#32;&#116;&#111;&#32;&#101;&#110;&#99;&#111;&#100;&#101;"2️⃣ Decoding text:$ python -m entity_everything decode "&#120;&#120;&#120;"
or
$ echo "&#120;&#120;&#120;" | python -m entity_everything decodeResult: "xxx"⚙️Technologies usedThe script has been written in Python.
It should work with versions 3.9 or higher.
This script does not require any dependencies.
Package: entitygraph-client
Maverick EntityGraph ClientThis is a Python client for theMaverick EntityGraph.Requirements.Python 3.7+Installation & Usagepip installpipinstallgit+https://github.com/bechtleav360/entitygraph-client.git(you may need to runpipwith root permission:sudo pip install git+https://github.com/bechtleav360/entitygraph-client.git)Then import the package:importentitygraphGetting StartedimportentitygraphfromentitygraphimportAdmin,Entity,Query,Application,TransactionfromrdflibimportSDO# Defining the host is optional and defaults to https://entitygraph.azurewebsites.netentitygraph.connect(api_key="123")# For application-specific operations, the Application class is essential.# In the following code, an application named "MyApp" is being retrieved.# Then, an entity with id "f3f34f" is obtained and converted into the n3 format.n3:str=Application().get_by_label("MyApp").Entity().get_by_id("f3f34f").n3()# For operations within the default application, the Admin, Entity, and Query classes can be directly invoked.# In the example below, an entity with id "g93h4g8" is retrieved and its "foaf.name" value is updated to "New Name".Entity().get_by_id("g93h4g8").set_value(SDO.title,"New Name")
Package: entity-gym
Entity GymEntity Gym is an open source Python library that defines anentity basedAPI for reinforcement learning environments.
Entity Gym extends the standard paradigm of fixed-size observation spaces by allowing observations to contain dynamically-sized lists of entities.
This enables a seamless and highly efficient interface with simulators, games, and other complex environments whose state can be naturally expressed as a collection of entities.Theenn-trainer librarycan be used to train agents for Entity Gym environments.Installationpip install entity-gymUsageYou can find tutorials, guides, and an API reference on theEntity Gym documentation website.ExamplesA number of simple example environments can be found inentity_gym/examples. More complex examples can be found in theENN-Zooproject, which contains Entity Gym bindings forProcgen,Griddly,MicroRTS,VizDoom, andCodeCraft.
Package: entity-gym-rs
EntityGym for RustEntityGymis a Python library that defines a novel entity-based abstraction for reinforcement learning environments which enables highly ergonomic and efficient training of deep reinforcement learning agents.
This crate provides bindings that allows Rust programs to be used as EntityGym training environments, and to load and run neural networks agents trained withEntity Neural Network Trainernatively in pure Rust applications.OverviewThe core abstraction in entity-gym-rs is theAgenttrait.
It defines a high-level API for neural network agents which allows them to directly interact with Rust data structures.
To use any of theAgentimplementations provided by entity-gym-rs, you just need to derive theActionandFeaturizabletraits, which define what information the agent can observe and what actions it can take:TheActiontraitallows a Rust type to be returned as an action by anAgent. This trait can be derived automatically for enums with only unit variants.TheFeaturizabletraitconverts objects into a format that can be processed by neural networks. It can be derived for most fixed-sizestructs, and forenums with unit variants.Agents can observe collections containing any number ofFeaturizableobjects.ExampleBasic example that demonstrates how to construct an observation and sample a random action from anAgent:useentity_gym_rs::agent::{Agent,AgentOps,Obs,Action,Featurizable};#[derive(Action, Debug)]enumMove{Up,Down,Left,Right}#[derive(Featurizable)]structPlayer{x:i32,y:i32}#[derive(Featurizable)]structCake{x:i32,y:i32,size:u32,}fnmain(){// Creates an agent that acts completely randomly.letmutagent=Agent::random();// Alternatively, load a trained neural network agent from a checkpoint.// let mut agent = Agent::load("agent");// Construct an observation with one `Player` entity and two `Cake entities.letobs=Obs::new(0.0).entities([Player{x:0,y:0}]).entities([Cake{x:4,y:0,size:4},Cake{x:10,y:42,size:12},]);// To obtain an action from an agent, we simple call the `act` method// with the observation we constructed.letaction=agent.act::<Move>(obs);println!("{:?}",action);}For a more complete example that includes training a neural network to play Snake, seeexamples/bevy_snake.Docsbevy_snake: Example of how to use entity-gym-rs in a Bevy game.bevy-snake-ai: More complex Bevy application with adversarial training of multiple agents to create AI opponents.EntityGym Rust API Docs: Rust API reference.If you have any questions, you can also get help onour discord server
Package: entitylinking-wikipedia
Entity Linking via WikiPediaThis package is used to perform Entity Linking based on Wikipedia based on user's input sentence.Check out below github page for more details:https://github.com/Soumyadipta-Maiti/Package-CreationInstallation of Packagepip install entitylinking-wikipediaSample Coding using this Packagefrom entitylinking_wikipedia import *import pandas as pdfinal_out = pd.DataFrame()final_out = Entity_Linking_via_Wikipedia('I work at IBM in Kolkata in India.')print(final_out)
Package: entityrdfizer
DescriptionTheentityrdfizerproject is designed to convert entities of any domain and their data and metadata into RDF.
It requires the entities and their data to be provided as inputs in an ABox CSV template, that is
filled in with data. A group of ABox CSV template files are provided under the following URL:https://github.com/cambridge-cares/TheWorldAvatar/tree/master/JPS_Ontology/KBTemplates/ABoxInstallationThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes.Virtual environment setupIt is highly recommended to use avirtual environmentfor theentityrdfizerinstallation. The virtual environment can be created as follows:(Windows)$ python -m venv entityrdfizer_venv
$ entityrdfizer_venv\Scripts\activate.bat
(entityrdfizer_venv) $(Linux)$python3-mvenventityrdfizer_venv
$sourceentityrdfizer_venv\bin\activate(entityrdfizer_venv)$The above commands will create and activate the virtual environmententityrdfizer_venvin the current directory.Installation via pipTo install theentityrdfizersimply run the following command:(entityrdfizer_venv)$pipinstallentityrdfizerInstallation from the version-controlled source (for developers)This type of installation is only for the developers. To installentityrdfizerdirectly from its repository you need to first clone theTheWorldAvatarproject. Then simply navigate to theTheWorldAvatar\EntityRDFizerdirectory and execute the following commands:# build and install(entityrdfizer_venv)$pipinstall.# or build for in-place development(entityrdfizer_venv)$pipinstall-e.Alternatively, use the providedinstall_rdfizer.shconvenience script, that can create virtual environment and install theentityrdfizerin one go:# create the environment and install the project$install_rdfizer.sh-v-i# create the environment and install the project for in-place development$install_rdfizer.sh-v-i-eNote that installing the project for in-place development (setting the-eflag) also installs the required python packages for development and testing. To test the code, simply run the following commands:(entityrdfizer_venv)$pytest# or(entityrdfizer_venv)$pytesttestsHow to useUsage:csv2rdf<csvFileOrDirPath>--csvType=<type>[--outDir=<dir>]Options:
--csvType=<type>Typeofthecsvfile.Choosebetweenabox/tbox[default:abox]--outDir=<dir>OutputdirectorypathAuthorsFeroz Farazi (msff2@cam.ac.uk), 17 May 2021
Package: entityrender
Simple entity span visualization in textThis is a simple widget, adapted from the code in Spacy visualizers, that can be used for simple visualization of text spans in Jupyter notebooks.To install:$ pip install entityrenderExample code:from IPython.core.display import HTML
from entityrender.entityrender import EntityRenderer

text = """When Sebastian Thrun started working on self-driving cars at Google in 2007,
few people outside of the company took him seriously."""

spans = [{"start": 5, "end": 20, "label": "Person"},
         {"start": 61, "end": 67, "label": "Company"},
         {"start": 71, "end": 75, "label": "Date"}]

er = EntityRenderer(labels=["Person", "Company", "Date"])
output = er.render_ents(text, spans)

HTML(output)Result:
Package: entity-resolution
ResolvERResolvER is an extensible framework for building Entity Resolution pipelines in order to merge datasets around "things" based on complex join logic and transitive linking.Entity Resolution is a complex and computationally expensive process. ResolvER seeks to provide tools that cover the majority of use cases, the ability to enhance those tools with machine learning, and leverage developers' experiential knowledge of data to provide a flexible and efficient solution to the Entity Resolution problem.Quick/Simple ExampleThe University of Leipzig providestest datasetsfor Entity Resolution, let's say you're working with the DBLP-ACM dataset.The dataset provides two files, both describing published papers, with similar columns:A unique id (unique to that file only)A titleA list of authorsA venueA yearThe titles vary slightly between files, and different authors may be listed for a given paper - in short, there's no clean or consistent way to deduplicate the data.Using ResolvER, you can specify any number of complex operations to determine whether two given records are duplicates of each other in what are called "Strategies." One such strategy may be:titlehas Levenshtein ratio of at least 0.9 ANDauthorshas Jaccard distance of at least 0.4 ANDyearis an exact matchIn Depth examplesFor more in depth workflows and explanations of the methodology, reference thenotebooksfolder.InstallInstall the latest version of ResolvER:$pipinstallentity-resolutionResearchResolvER is (most notably) inspired by the below publications:Collective Entity Resolution in Relational DataComparative Analysis of Approximate
Blocking Techniques for Entity ResolutionLicenseReleased under standard MIT license (see LICENSE.txt):Copyright (c) 2021 ResolvER Developers
Carl Best
Package: entity-resolution-evaluation
entity-resolution-evaluationA python package to evaluate entity resolutionThis package allows to evaluate entity resolution by efficiently computing several state of the art metrics : basic merge distance, precision, recall, variation of information. It's using the slice algorithm from the paper :Menestrina, David and Whang, Steven Euijong and Garcia-Molina, Hector (2010) Evaluating Entity Resolution Resultshttp://ilpubs.stanford.edu:8090/975/3/ERMetricVLDB.pdfGetting StartedInstallingpipinstallentity-resolution-evaluationTestingEvaluate your resolutionRagainst the gold standardSusing ametric.ExamplesS = [[0, 1], [2, 3, 4], [5]]
R = [[0, 1, 2], [3, 4], [5]]

evaluate(R,S, 'bmd')
# returns 2To go from R to S, you have to do 1 split and 1 merge.evaluate(R,S,'precision')
# returns 0.5,Half of the pairs of R are incorrect. (0,2) and (1,2) are incorrect. (0,1) and (3,4) are correctevaluate(R,S,'recall')
# returns 0.5Half of the pairs of S are present in R. (0,1) and (3,4) are present. (2,3) and (2,4) are absent.evaluate(R,S,'variation of information')
# returns 0.6365141682948129MetricsYou can currently compute the following metrics :metricvalue if perfectboundsintepretation'bmd'0[0,infinity]basic merge distance : the number of split and merge necessary to go from R to S'precision'1[0,1]proportion of pairs in R present in S'recall'1[0,1]proportion of pairs in S present in R'f1'1[0,1]harmonic mean of precision and recall'variation_of_information'0[0,infinity]amount of information that is lost and added to go from R to SCreditsPlease visit theHopkins missionpage for more informationLicenseMIT LicenseCopyright (c) 2018 Ministère de l'Action et des Comptes Publics, Paul Boosz, Benoît GuigalPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.